grpc 1.43.1 → 1.44.0.pre2

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

@@ -149,7 +149,11 @@ static void combiner_exec(grpc_core::Combiner* lock, grpc_closure* cl,
   }
   GPR_ASSERT(last & STATE_UNORPHANED);  // ensure lock has not been destroyed
   assert(cl->cb);
-  cl->error_data.error = error;
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  cl->error_data.error = grpc_core::internal::StatusAllocHeapPtr(error);
+#else
+  cl->error_data.error = reinterpret_cast<intptr_t>(error);
+#endif
   lock->queue.Push(cl->next_data.mpscq_node.get());
 }
 
@@ -221,12 +225,21 @@ bool grpc_combiner_continue_exec_ctx() {
       return true;
     }
     grpc_closure* cl = reinterpret_cast<grpc_closure*>(n);
-    grpc_error_handle cl_err = cl->error_data.error;
 #ifndef NDEBUG
     cl->scheduled = false;
 #endif
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+    grpc_error_handle cl_err =
+        grpc_core::internal::StatusMoveFromHeapPtr(cl->error_data.error);
+    cl->error_data.error = 0;
+    cl->cb(cl->cb_arg, std::move(cl_err));
+#else
+    grpc_error_handle cl_err =
+        reinterpret_cast<grpc_error_handle>(cl->error_data.error);
+    cl->error_data.error = 0;
     cl->cb(cl->cb_arg, cl_err);
     GRPC_ERROR_UNREF(cl_err);
+#endif
   } else {
     grpc_closure* c = lock->final_list.head;
     GPR_ASSERT(c != nullptr);
@@ -236,12 +249,21 @@ bool grpc_combiner_continue_exec_ctx() {
       GRPC_COMBINER_TRACE(
           gpr_log(GPR_INFO, "C:%p execute_final[%d] c=%p", lock, loops, c));
       grpc_closure* next = c->next_data.next;
-      grpc_error_handle error = c->error_data.error;
 #ifndef NDEBUG
       c->scheduled = false;
 #endif
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+      grpc_error_handle error =
+          grpc_core::internal::StatusMoveFromHeapPtr(c->error_data.error);
+      c->error_data.error = 0;
+      c->cb(c->cb_arg, std::move(error));
+#else
+      grpc_error_handle error =
+          reinterpret_cast<grpc_error_handle>(c->error_data.error);
+      c->error_data.error = 0;
       c->cb(c->cb_arg, error);
       GRPC_ERROR_UNREF(error);
+#endif
       c = next;
     }
   }

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

@@ -252,6 +252,8 @@ static const char* error_int_name(grpc_error_ints key) {
       return "channel_connectivity_state";
     case GRPC_ERROR_INT_LB_POLICY_DROP:
       return "lb_policy_drop";
+    case GRPC_ERROR_INT_STREAM_NETWORK_STATE:
+      return "stream_network_state";
     case GRPC_ERROR_INT_MAX:
       GPR_UNREACHABLE_CODE(return "unknown");
   }

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

@@ -96,6 +96,9 @@ typedef enum {
   /// LB policy drop
   GRPC_ERROR_INT_LB_POLICY_DROP =
       static_cast<int>(grpc_core::StatusIntProperty::kLbPolicyDrop),
+  /// stream network state
+  GRPC_ERROR_INT_STREAM_NETWORK_STATE =
+      static_cast<int>(grpc_core::StatusIntProperty::kStreamNetworkState),
 
   /// Must always be last
   GRPC_ERROR_INT_MAX,

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

@@ -18,6 +18,7 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/event_engine/resolver.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -29,7 +30,6 @@ extern grpc_tcp_server_vtable grpc_event_engine_tcp_server_vtable;
 extern grpc_timer_vtable grpc_event_engine_timer_vtable;
 extern grpc_pollset_vtable grpc_event_engine_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_event_engine_pollset_set_vtable;
-extern grpc_address_resolver_vtable grpc_event_engine_resolver_vtable;
 
 // Disabled by default. grpc_polling_trace must be defined in all iomgr
 // implementations due to its usage in lockfree_event.
@@ -75,7 +75,8 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_timer_impl(&grpc_event_engine_timer_vtable);
   grpc_set_pollset_vtable(&grpc_event_engine_pollset_vtable);
   grpc_set_pollset_set_vtable(&grpc_event_engine_pollset_set_vtable);
-  grpc_set_resolver_impl(&grpc_event_engine_resolver_vtable);
+  grpc_core::SetDNSResolver(
+      grpc_core::experimental::EventEngineDNSResolver::GetOrCreate());
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 

data/src/core/lib/iomgr/event_engine/resolved_address_internal.cc

@@ -37,5 +37,11 @@ grpc_resolved_address CreateGRPCResolvedAddress(
   return grpc_addr;
 }
 
+// TODO(ctiller): Move this to somewhere more permanent as we're deleting iomgr.
+std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr) {
+  auto gra = CreateGRPCResolvedAddress(addr);
+  return grpc_sockaddr_to_uri(&gra);
+}
+
 }  // namespace experimental
 }  // namespace grpc_event_engine

data/src/core/lib/iomgr/event_engine/resolved_address_internal.h

@@ -29,6 +29,8 @@ EventEngine::ResolvedAddress CreateResolvedAddress(
 grpc_resolved_address CreateGRPCResolvedAddress(
     const EventEngine::ResolvedAddress& ra);
 
+std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr);
+
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

data/src/core/lib/iomgr/event_engine/resolver.cc

@@ -24,11 +24,15 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/event_engine/promise.h"
 #include "src/core/lib/iomgr/event_engine/resolved_address_internal.h"
+#include "src/core/lib/iomgr/event_engine/resolver.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolve_address_impl.h"
 #include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/surface/init.h"
 #include "src/core/lib/transport/error_utils.h"
 
+namespace grpc_core {
+namespace experimental {
 namespace {
 using ::grpc_event_engine::experimental::CreateGRPCResolvedAddress;
 using ::grpc_event_engine::experimental::EventEngine;
@@ -39,77 +43,91 @@ using ::grpc_event_engine::experimental::Promise;
 ///
 /// This provides a place to store the ownership of the DNSResolver object until
 /// the request is complete.
-class DnsRequest {
+class EventEngineDNSRequest : DNSRequest {
  public:
-  DnsRequest(std::unique_ptr<EventEngine::DNSResolver> dns_resolver,
-             absl::string_view address, absl::string_view default_port,
-             grpc_closure* on_done, grpc_resolved_addresses** addresses)
+  EventEngineDNSRequest(std::unique_ptr<EventEngine::DNSResolver> dns_resolver,
+                        absl::string_view name, absl::string_view default_port,
+                        grpc_closure* on_done,
+                        std::vector<grpc_resolved_address>* addresses)
       : dns_resolver_(std::move(dns_resolver)),
-        cb_(on_done),
-        addresses_(addresses) {
+        name_(std::string(name)),
+        default_port_(std::string(default_port)),
+        on_done_(std::move(on_done)) {}
+
+  void Start() override {
+    if (dns_resolver_ == nullptr) {
+      new DNSCallbackExecCtxScheduler(
+          std::move(on_done_),
+          absl::UnknownError("Failed to get DNS Resolver."));
+      return;
+    }
+    Ref().release();  // ref held by pending resolution
     dns_resolver_->LookupHostname(
-        absl::bind_front(&DnsRequest::OnLookupComplete, this), address,
-        default_port, absl::InfiniteFuture());
+        absl::bind_front(&EventEngineDNSRequest::OnLookupComplete, this), name_,
+        default_port_, absl::InfiniteFuture());
   }
 
+  // TOOD(hork): implement cancellation; currently it's a no-op
+  void Orphan() override { Unref(); }
+
  private:
   void OnLookupComplete(
       absl::StatusOr<std::vector<EventEngine::ResolvedAddress>> addresses) {
-    grpc_core::ExecCtx exec_ctx;
+    ExecCtx exec_ctx;
     // Convert addresses to iomgr form.
-    *addresses_ = static_cast<grpc_resolved_addresses*>(
-        gpr_malloc(sizeof(grpc_resolved_addresses)));
-    (*addresses_)->naddrs = addresses->size();
-    (*addresses_)->addrs = static_cast<grpc_resolved_address*>(
-        gpr_malloc(sizeof(grpc_resolved_address) * addresses->size()));
+    std::vector<grpc_resolved_address> result;
+    results.reserve(addresses->size());
     for (size_t i = 0; i < addresses->size(); ++i) {
-      (*addresses_)->addrs[i] = CreateGRPCResolvedAddress((*addresses)[i]);
+      results.push_back(CreateGRPCResolvedAddress(addresses[i]));
+    }
+    if (addresses.ok()) {
+      on_done_(std::move(result));
+    } else {
+      on_done_(addresses.status());
     }
-    grpc_closure* cb = cb_;
-    delete this;
-    grpc_core::Closure::Run(DEBUG_LOCATION, cb,
-                            absl_status_to_grpc_error(addresses.status()));
+    Unref();
   }
 
   std::unique_ptr<EventEngine::DNSResolver> dns_resolver_;
-  grpc_closure* cb_;
-  grpc_resolved_addresses** addresses_;
+  const std::string name_;
+  const std::string default_port_;
+  std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+      on_done_;
 };
 
-void resolve_address(const char* addr, const char* default_port,
-                     grpc_pollset_set* /* interested_parties */,
-                     grpc_closure* on_done,
-                     grpc_resolved_addresses** addresses) {
-  std::unique_ptr<EventEngine::DNSResolver> dns_resolver =
-      GetDefaultEventEngine()->GetDNSResolver();
-  if (dns_resolver == nullptr) {
-    grpc_core::ExecCtx::Run(
-        DEBUG_LOCATION, on_done,
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to get DNS Resolver."));
-    return;
-  }
-  new DnsRequest(std::move(dns_resolver), addr, default_port, on_done,
-                 addresses);
+}  // namespace
+
+DNSResolver* EventEngineDNSResolver::GetOrCreate() {
+  static EventEngineDNSResolver* instance = new EventEngineDNSResolver();
+  return instance;
 }
 
-void blocking_handle_async_resolve_done(void* arg, grpc_error_handle error) {
-  static_cast<Promise<grpc_error_handle>*>(arg)->Set(std::move(error));
+OrphanablePtr<DNSResolver::Request> EventEngineDNSResolver::ResolveName(
+    absl::string_view name, absl::string_view default_port,
+    grpc_pollset_set* /* interested_parties */,
+    std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+        on_done) {
+  std::unique_ptr<EventEngine::DNSResolver> dns_resolver =
+      GetDefaultEventEngine()->GetDNSResolver();
+  return MakeOrphanable<EventEngineDNSRequest>(
+      std::move(dns_resolver), name, default_port, std::move(on_done));
 }
 
-grpc_error_handle blocking_resolve_address(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses) {
+absl::StatusOr<std::vector<grpc_resolved_address>>
+EventEngineDNSResolver::ResolveNameBlocking(absl::string_view name,
+                                            absl::string_view default_port) {
   grpc_closure on_done;
-  Promise<grpc_error_handle> evt;
-  GRPC_CLOSURE_INIT(&on_done, blocking_handle_async_resolve_done, &evt,
-                    grpc_schedule_on_exec_ctx);
-  resolve_address(name, default_port, nullptr, &on_done, addresses);
+  Promise<absl::StatusOr<std::vector<grpc_resolved_address>>> evt;
+  auto r = ResolveName(
+      name, default_port,
+      [&evt](void(absl::StatusOr<std::vector<grpc_resolved_address>> result) {
+        evt.Set(std::move(result));
+      }));
+  r->Start();
   return evt.Get();
 }
 
-}  // namespace
-
-grpc_address_resolver_vtable grpc_event_engine_resolver_vtable{
-    resolve_address, blocking_resolve_address};
+}  // namespace experimental
+}  // namespace grpc_core
 
 #endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/iomgr/event_engine/resolver.h

@@ -0,0 +1,56 @@
+//
+// Copyright 2015 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_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVER_H
+#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string.h>
+#include <sys/types.h>
+
+#include <functional>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/time.h>
+
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+namespace grpc_core {
+namespace experimental {
+
+class EventEngineDNSResolver : public DNSResolver {
+ public:
+  // Gets the singleton instance, creating it first if it doesn't exist
+  static EventEngineDNSResolver* GetOrCreate();
+
+  OrphanablePtr<DNSResolver::Request> ResolveName(
+      absl::string_view name, absl::string_view default_port,
+      grpc_pollset_set* interested_parties,
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_done) override;
+
+  absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
+      absl::string_view name, absl::string_view default_port) override;
+};
+
+}  // namespace experimental
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_RESOLVER_H

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

@@ -27,7 +27,7 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/profiling/timers.h"
 
-static void exec_ctx_run(grpc_closure* closure, grpc_error_handle error) {
+static void exec_ctx_run(grpc_closure* closure) {
 #ifndef NDEBUG
   closure->scheduled = false;
   if (grpc_trace_closure.enabled()) {
@@ -37,18 +37,27 @@ static void exec_ctx_run(grpc_closure* closure, grpc_error_handle error) {
             closure->line_initiated);
   }
 #endif
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  grpc_error_handle error =
+      grpc_core::internal::StatusMoveFromHeapPtr(closure->error_data.error);
+  closure->error_data.error = 0;
+  closure->cb(closure->cb_arg, std::move(error));
+#else
+  grpc_error_handle error =
+      reinterpret_cast<grpc_error_handle>(closure->error_data.error);
+  closure->error_data.error = 0;
   closure->cb(closure->cb_arg, error);
+  GRPC_ERROR_UNREF(error);
+#endif
 #ifndef NDEBUG
   if (grpc_trace_closure.enabled()) {
     gpr_log(GPR_DEBUG, "closure %p finished", closure);
   }
 #endif
-  GRPC_ERROR_UNREF(error);
 }
 
-static void exec_ctx_sched(grpc_closure* closure, grpc_error_handle error) {
-  grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(), closure,
-                           error);
+static void exec_ctx_sched(grpc_closure* closure) {
+  grpc_closure_list_append(grpc_core::ExecCtx::Get()->closure_list(), closure);
 }
 
 static gpr_timespec g_start_time;
@@ -151,9 +160,8 @@ bool ExecCtx::Flush() {
       closure_list_.head = closure_list_.tail = nullptr;
       while (c != nullptr) {
         grpc_closure* next = c->next_data.next;
-        grpc_error_handle error = c->error_data.error;
         did_something = true;
-        exec_ctx_run(c, error);
+        exec_ctx_run(c);
         c = next;
       }
     } else if (!grpc_combiner_continue_exec_ctx()) {
@@ -195,7 +203,12 @@ void ExecCtx::Run(const DebugLocation& location, grpc_closure* closure,
   closure->run = false;
   GPR_ASSERT(closure->cb != nullptr);
 #endif
-  exec_ctx_sched(closure, error);
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+  closure->error_data.error = internal::StatusAllocHeapPtr(error);
+#else
+  closure->error_data.error = reinterpret_cast<intptr_t>(error);
+#endif
+  exec_ctx_sched(closure);
 }
 
 void ExecCtx::RunList(const DebugLocation& location, grpc_closure_list* list) {
@@ -218,7 +231,7 @@ void ExecCtx::RunList(const DebugLocation& location, grpc_closure_list* list) {
     c->run = false;
     GPR_ASSERT(c->cb != nullptr);
 #endif
-    exec_ctx_sched(c, c->error_data.error);
+    exec_ctx_sched(c);
     c = next;
   }
   list->head = list->tail = nullptr;

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

@@ -114,7 +114,6 @@ size_t Executor::RunClosures(const char* executor_name,
   grpc_closure* c = list.head;
   while (c != nullptr) {
     grpc_closure* next = c->next_data.next;
-    grpc_error_handle error = c->error_data.error;
 #ifndef NDEBUG
     EXECUTOR_TRACE("(%s) run %p [created by %s:%d]", executor_name, c,
                    c->file_created, c->line_created);
@@ -122,8 +121,18 @@ size_t Executor::RunClosures(const char* executor_name,
 #else
     EXECUTOR_TRACE("(%s) run %p", executor_name, c);
 #endif
+#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
+    grpc_error_handle error =
+        internal::StatusMoveFromHeapPtr(c->error_data.error);
+    c->error_data.error = 0;
+    c->cb(c->cb_arg, std::move(error));
+#else
+    grpc_error_handle error =
+        reinterpret_cast<grpc_error_handle>(c->error_data.error);
+    c->error_data.error = 0;
     c->cb(c->cb_arg, error);
     GRPC_ERROR_UNREF(error);
+#endif
     c = next;
     n++;
     ExecCtx::Get()->Flush();

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

@@ -67,12 +67,13 @@ void grpc_prefork() {
   if (poll_strategy_name == nullptr ||
       (strcmp(poll_strategy_name, "epoll1") != 0 &&
        strcmp(poll_strategy_name, "poll") != 0)) {
-    gpr_log(GPR_INFO,
+    gpr_log(GPR_ERROR,
             "Fork support is only compatible with the epoll1 and poll polling "
             "strategies");
+    return;
   }
   if (!grpc_core::Fork::BlockExecCtx()) {
-    gpr_log(GPR_INFO,
+    gpr_log(GPR_ERROR,
             "Other threads are currently calling into gRPC, skipping fork() "
             "handlers");
     return;

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

@@ -68,7 +68,10 @@ void grpc_custom_iomgr_init(grpc_socket_vtable* socket,
   grpc_custom_timer_init(timer);
   grpc_custom_pollset_init(poller);
   grpc_custom_pollset_set_init();
-  grpc_custom_resolver_init(resolver);
+  grpc_core::CustomDNSResolver::Create(resolver);
+  grpc_core::CustomDNSResolver* custom_dns_resolver =
+      grpc_core::CustomDNSResolver::Get();
+  grpc_core::SetDNSResolver(custom_dns_resolver);
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 

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

@@ -26,6 +26,7 @@
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolve_address_posix.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -36,7 +37,6 @@ extern grpc_tcp_client_vtable grpc_posix_tcp_client_vtable;
 extern grpc_timer_vtable grpc_generic_timer_vtable;
 extern grpc_pollset_vtable grpc_posix_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_posix_pollset_set_vtable;
-extern grpc_address_resolver_vtable grpc_posix_resolver_vtable;
 
 static void iomgr_platform_init(void) {
   grpc_wakeup_fd_global_init();
@@ -79,7 +79,7 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
   grpc_set_pollset_vtable(&grpc_posix_pollset_vtable);
   grpc_set_pollset_set_vtable(&grpc_posix_pollset_set_vtable);
-  grpc_set_resolver_impl(&grpc_posix_resolver_vtable);
+  grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 

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

@@ -41,6 +41,7 @@
 #include "src/core/lib/iomgr/ev_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolve_address_posix.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -55,7 +56,6 @@ extern grpc_tcp_client_vtable grpc_cfstream_client_vtable;
 extern grpc_timer_vtable grpc_generic_timer_vtable;
 extern grpc_pollset_vtable grpc_posix_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_posix_pollset_set_vtable;
-extern grpc_address_resolver_vtable grpc_posix_resolver_vtable;
 
 static void apple_iomgr_platform_init(void) { grpc_pollset_global_init(); }
 
@@ -178,7 +178,7 @@ void grpc_set_default_iomgr_platform() {
     grpc_set_iomgr_platform_vtable(&apple_vtable);
   }
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
-  grpc_set_resolver_impl(&grpc_posix_resolver_vtable);
+  grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
 }
 
 bool grpc_iomgr_run_in_background() {

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

@@ -28,6 +28,7 @@
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset_windows.h"
 #include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolve_address_windows.h"
 #include "src/core/lib/iomgr/sockaddr_windows.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 #include "src/core/lib/iomgr/tcp_client.h"
@@ -39,7 +40,6 @@ extern grpc_tcp_client_vtable grpc_windows_tcp_client_vtable;
 extern grpc_timer_vtable grpc_generic_timer_vtable;
 extern grpc_pollset_vtable grpc_windows_pollset_vtable;
 extern grpc_pollset_set_vtable grpc_windows_pollset_set_vtable;
-extern grpc_address_resolver_vtable grpc_windows_resolver_vtable;
 
 /* Windows' io manager is going to be fully designed using IO completion
    ports. All of what we're doing here is basically make sure that
@@ -96,7 +96,7 @@ void grpc_set_default_iomgr_platform() {
   grpc_set_timer_impl(&grpc_generic_timer_vtable);
   grpc_set_pollset_vtable(&grpc_windows_pollset_vtable);
   grpc_set_pollset_set_vtable(&grpc_windows_pollset_set_vtable);
-  grpc_set_resolver_impl(&grpc_windows_resolver_vtable);
+  grpc_core::SetDNSResolver(grpc_core::NativeDNSResolver::GetOrCreate());
   grpc_set_iomgr_platform_vtable(&vtable);
 }
 

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

@@ -73,9 +73,9 @@
 #if __GLIBC_PREREQ(2, 10)
 #define GRPC_LINUX_SOCKETUTILS 1
 #endif
-#if !(__GLIBC_PREREQ(2, 17))
+#if !(__GLIBC_PREREQ(2, 18))
 /*
- * TCP_USER_TIMEOUT wasn't imported to glibc until 2.17. Use Linux system
+ * TCP_USER_TIMEOUT wasn't imported to glibc until 2.18. Use Linux system
  * header instead.
  */
 #define GRPC_LINUX_TCP_H 1

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

@@ -24,32 +24,13 @@
 
 namespace grpc_core {
 const char* kDefaultSecurePort = "https";
-}  // namespace grpc_core
-
-grpc_address_resolver_vtable* grpc_resolve_address_impl;
 
-void grpc_set_resolver_impl(grpc_address_resolver_vtable* vtable) {
-  grpc_resolve_address_impl = vtable;
+namespace {
+DNSResolver* g_dns_resolver;
 }
 
-void grpc_resolve_address(const char* addr, const char* default_port,
-                          grpc_pollset_set* interested_parties,
-                          grpc_closure* on_done,
-                          grpc_resolved_addresses** addresses) {
-  grpc_resolve_address_impl->resolve_address(
-      addr, default_port, interested_parties, on_done, addresses);
-}
+void SetDNSResolver(DNSResolver* resolver) { g_dns_resolver = resolver; }
 
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses) {
-  if (addresses != nullptr) {
-    gpr_free(addresses->addrs);
-  }
-  gpr_free(addresses);
-}
+DNSResolver* GetDNSResolver() { return g_dns_resolver; }
 
-grpc_error_handle grpc_blocking_resolve_address(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses) {
-  return grpc_resolve_address_impl->blocking_resolve_address(name, default_port,
-                                                             addresses);
-}
+}  // namespace grpc_core