grpc 1.42.0 → 1.49.1

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

@@ -45,6 +45,13 @@ GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_abort_on_leaks, false,
                               "A debugging aid to cause a call to abort() when "
                               "gRPC objects are leaked past grpc_shutdown()");
 
+GPR_GLOBAL_CONFIG_DEFINE_BOOL(
+    grpc_experimental_enable_tcp_frame_size_tuning, false,
+    "If set, enables TCP to use RPC size estimation made by higher layers. TCP "
+    "would not indicate completion of a read operation until a specified "
+    "number of bytes have been read over the socket. Buffers are also "
+    "allocated according to estimated RPC sizes.");
+
 static gpr_mu g_mu;
 static gpr_cv g_rcv;
 static int g_shutdown;
@@ -64,7 +71,6 @@ void grpc_iomgr_init() {
   g_root_object.name = const_cast<char*>("root");
   grpc_iomgr_platform_init();
   grpc_timer_list_init();
-  grpc_core::grpc_errqueue_init();
   g_grpc_abort_on_leaks = GPR_GLOBAL_CONFIG_GET(grpc_abort_on_leaks);
 }
 

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

@@ -0,0 +1,25 @@
+// Copyright 2022 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_IOMGR_FWD_H
+#define GRPC_CORE_LIB_IOMGR_IOMGR_FWD_H
+
+// A bunch of forward declarations that are useful to higher level things that
+// don't want to depend on all of iomgr.
+
+#include <grpc/support/port_platform.h>
+
+typedef struct grpc_pollset_set grpc_pollset_set;
+
+#endif  // GRPC_CORE_LIB_IOMGR_IOMGR_FWD_H

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,8 @@ 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_tcp_client_global_init();
   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(); }
 
@@ -177,8 +177,9 @@ void grpc_set_default_iomgr_platform() {
     grpc_set_pollset_set_vtable(&grpc_apple_pollset_set_vtable);
     grpc_set_iomgr_platform_vtable(&apple_vtable);
   }
+  grpc_tcp_client_global_init();
   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/load_file.cc

@@ -66,7 +66,7 @@ grpc_error_handle grpc_load_file(const char* filename, int add_null_terminator,
 end:
   *output = result;
   if (file != nullptr) fclose(file);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     grpc_error_handle error_out =
         grpc_error_set_str(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                                "Failed to load file", &error, 1),

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

@@ -77,11 +77,7 @@ void LockfreeEvent::DestroyEvent() {
   do {
     curr = gpr_atm_no_barrier_load(&state_);
     if (curr & kShutdownBit) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
       internal::StatusFreeHeapPtr(curr & ~kShutdownBit);
-#else
-      GRPC_ERROR_UNREF((grpc_error_handle)(curr & ~kShutdownBit));
-#endif
     } else {
       GPR_ASSERT(curr == kClosureNotReady || curr == kClosureReady);
     }
@@ -143,13 +139,8 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
            contains a pointer to the shutdown-error). If the fd is shutdown,
            schedule the closure with the shutdown error */
         if ((curr & kShutdownBit) > 0) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
           grpc_error_handle shutdown_err =
               internal::StatusGetFromHeapPtr(curr & ~kShutdownBit);
-#else
-          grpc_error_handle shutdown_err =
-              reinterpret_cast<grpc_error_handle>(curr & ~kShutdownBit);
-#endif
           ExecCtx::Run(DEBUG_LOCATION, closure,
                        GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
                            "FD Shutdown", &shutdown_err, 1));
@@ -169,12 +160,8 @@ void LockfreeEvent::NotifyOn(grpc_closure* closure) {
 }
 
 bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
   intptr_t status_ptr = internal::StatusAllocHeapPtr(shutdown_error);
   gpr_atm new_state = status_ptr | kShutdownBit;
-#else
-  gpr_atm new_state = reinterpret_cast<gpr_atm>(shutdown_error) | kShutdownBit;
-#endif
 
   while (true) {
     gpr_atm curr = gpr_atm_no_barrier_load(&state_);
@@ -198,11 +185,7 @@ bool LockfreeEvent::SetShutdown(grpc_error_handle shutdown_error) {
 
         /* If fd is already shutdown, we are done */
         if ((curr & kShutdownBit) > 0) {
-#ifdef GRPC_ERROR_IS_ABSEIL_STATUS
           internal::StatusFreeHeapPtr(status_ptr);
-#else
-          GRPC_ERROR_UNREF(shutdown_error);
-#endif
           return false;
         }
 

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

@@ -23,6 +23,7 @@
 
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/promise/context.h"
 
 typedef enum grpc_pollset_tag {
   GRPC_POLLS_NONE,
@@ -65,4 +66,9 @@ void grpc_polling_entity_add_to_pollset_set(grpc_polling_entity* pollent,
 void grpc_polling_entity_del_from_pollset_set(grpc_polling_entity* pollent,
                                               grpc_pollset_set* pss_dst);
 
+namespace grpc_core {
+template <>
+struct ContextType<grpc_polling_entity> {};
+}  // namespace grpc_core
+
 #endif /* GRPC_CORE_LIB_IOMGR_POLLING_ENTITY_H */

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

@@ -44,7 +44,7 @@ void grpc_pollset_destroy(grpc_pollset* pollset) {
 
 grpc_error_handle grpc_pollset_work(grpc_pollset* pollset,
                                     grpc_pollset_worker** worker,
-                                    grpc_millis deadline) {
+                                    grpc_core::Timestamp deadline) {
   return grpc_pollset_impl->work(pollset, worker, deadline);
 }
 

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

@@ -45,7 +45,7 @@ typedef struct grpc_pollset_vtable {
   void (*shutdown)(grpc_pollset* pollset, grpc_closure* closure);
   void (*destroy)(grpc_pollset* pollset);
   grpc_error_handle (*work)(grpc_pollset* pollset, grpc_pollset_worker** worker,
-                            grpc_millis deadline);
+                            grpc_core::Timestamp deadline);
   grpc_error_handle (*kick)(grpc_pollset* pollset,
                             grpc_pollset_worker* specific_worker);
   size_t (*pollset_size)(void);
@@ -86,9 +86,9 @@ void grpc_pollset_destroy(grpc_pollset* pollset);
    May call grpc_closure_list_run on grpc_closure_list, without holding the
    pollset
    lock */
-grpc_error_handle grpc_pollset_work(grpc_pollset* pollset,
-                                    grpc_pollset_worker** worker,
-                                    grpc_millis deadline) GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_pollset_work(
+    grpc_pollset* pollset, grpc_pollset_worker** worker,
+    grpc_core::Timestamp deadline) GRPC_MUST_USE_RESULT;
 
 /* Break one polling thread out of polling work for this pollset.
    If specific_worker is non-NULL, then kick that worker. */

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

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/pollset.h"
 
 /* A grpc_pollset_set is a set of pollsets that are interested in an
@@ -28,8 +29,6 @@
    fd's (etc) that have been registered with the set_set to that pollset.
    Registering fd's automatically adds them to all current pollsets. */
 
-typedef struct grpc_pollset_set grpc_pollset_set;
-
 typedef struct grpc_pollset_set_vtable {
   grpc_pollset_set* (*create)(void);
   void (*destroy)(grpc_pollset_set* pollset_set);

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

@@ -108,7 +108,7 @@ static void pollset_destroy(grpc_pollset* pollset) {}
 
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker_hdl,
-                                      grpc_millis deadline) {
+                                      grpc_core::Timestamp deadline) {
   grpc_pollset_worker worker;
   if (worker_hdl) *worker_hdl = &worker;
 
@@ -159,7 +159,7 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
     added_worker = 1;
     while (!worker.kicked) {
       if (gpr_cv_wait(&worker.cv, &grpc_polling_mu,
-                      grpc_millis_to_timespec(deadline, GPR_CLOCK_REALTIME))) {
+                      deadline.as_timespec(GPR_CLOCK_REALTIME))) {
         grpc_core::ExecCtx::Get()->InvalidateNow();
         break;
       }

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

@@ -20,16 +20,15 @@
 
 #include <grpc/support/port_platform.h>
 
+// IWYU pragma: no_include <features.h>
+// IWYU pragma: no_include <linux/version.h>
+
 /* This needs to be separate from the other conditions because it needs to
  * apply to custom sockets too */
 #ifdef GPR_WINDOWS
 #define GRPC_ARES_RESOLVE_LOCALHOST_MANUALLY 1
 #endif
-#if defined(GRPC_CUSTOM_SOCKET)
-// Do Nothing
-#elif defined(GRPC_USE_EVENT_ENGINE)
-// Do Nothing
-#elif defined(GPR_WINDOWS)
+#if defined(GPR_WINDOWS)
 #define GRPC_WINSOCK_SOCKET 1
 #define GRPC_WINDOWS_SOCKETUTILS 1
 #define GRPC_WINDOWS_SOCKET_ARES_EV_DRIVER 1
@@ -73,9 +72,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
@@ -109,7 +108,6 @@
 #define GRPC_POSIX_SOCKET_ARES_EV_DRIVER 1
 #define GRPC_POSIX_SOCKET_EV 1
 #define GRPC_POSIX_SOCKET_EV_EPOLL1 1
-#define GRPC_POSIX_SOCKET_EV_EPOLLEX 1
 #define GRPC_POSIX_SOCKET_EV_POLL 1
 #define GRPC_POSIX_SOCKET_IF_NAMETOINDEX 1
 #define GRPC_POSIX_SOCKET_RESOLVE_ADDRESS 1
@@ -158,6 +156,17 @@
 #define GRPC_POSIX_SOCKET 1
 #define GRPC_POSIX_SOCKETUTILS 1
 #define GRPC_POSIX_WAKEUP_FD 1
+#elif defined(GPR_NETBSD)
+#define GRPC_HAVE_ARPA_NAMESER 1
+#define GRPC_HAVE_IFADDRS 1
+#define GRPC_HAVE_IPV6_RECVPKTINFO 1
+#define GRPC_HAVE_SO_NOSIGPIPE 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+#define GRPC_POSIX_FORK 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_POSIX_WAKEUP_FD 1
 #elif defined(GPR_NACL)
 #define GRPC_HAVE_ARPA_NAMESER 1
 #define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
@@ -180,22 +189,30 @@
 // TODO(rudominer) Check this does something we want.
 #define GRPC_POSIX_SOCKETUTILS 1
 #define GRPC_TIMER_USE_GENERIC 1
+#elif defined(GPR_HAIKU)
+#define GRPC_HAVE_ARPA_NAMESER 1
+#define GRPC_HAVE_IFADDRS 1
+#define GRPC_HAVE_IPV6_RECVPKTINFO 1
+#define GRPC_HAVE_UNIX_SOCKET 1
+#define GRPC_POSIX_FORK 1
+#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1
+#define GRPC_POSIX_SOCKET 1
+#define GRPC_POSIX_SOCKETUTILS 1
+#define GRPC_POSIX_WAKEUP_FD 1
 #elif !defined(GPR_NO_AUTODETECT_PLATFORM)
 #error "Platform not recognized"
 #endif
 
 #if defined(GRPC_POSIX_SOCKET) + defined(GRPC_WINSOCK_SOCKET) + \
-        defined(GRPC_CUSTOM_SOCKET) + defined(GRPC_CFSTREAM) +  \
-        defined(GRPC_USE_EVENT_ENGINE) !=                       \
+        defined(GRPC_CFSTREAM) !=                               \
     1
 #error \
-    "Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GRPC_CUSTOM_SOCKET, GRPC_CFSTREAM, GRPC_USE_EVENT_ENGINE"
+    "Must define exactly one of GRPC_POSIX_SOCKET, GRPC_WINSOCK_SOCKET, GRPC_CFSTREAM"
 #endif
 
 #ifdef GRPC_POSIX_SOCKET
 #define GRPC_POSIX_SOCKET_ARES_EV_DRIVER 1
 #define GRPC_POSIX_SOCKET_EV 1
-#define GRPC_POSIX_SOCKET_EV_EPOLLEX 1
 #define GRPC_POSIX_SOCKET_EV_POLL 1
 #define GRPC_POSIX_SOCKET_EV_EPOLL1 1
 #define GRPC_POSIX_SOCKET_IF_NAMETOINDEX 1

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

@@ -19,37 +19,26 @@
 
 #include "src/core/lib/iomgr/resolve_address.h"
 
+#include "absl/strings/str_cat.h"
+
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 
 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);
-}
+constexpr DNSResolver::TaskHandle DNSResolver::kNullHandle;
 
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses) {
-  if (addresses != nullptr) {
-    gpr_free(addresses->addrs);
-  }
-  gpr_free(addresses);
-}
+void SetDNSResolver(DNSResolver* resolver) { g_dns_resolver = resolver; }
+
+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);
+std::string DNSResolver::HandleToString(TaskHandle handle) {
+  return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
 }
+
+}  // namespace grpc_core

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

@@ -23,61 +23,94 @@
 
 #include <stddef.h>
 
-#include "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_WINSOCK_SOCKET
-#include <ws2tcpip.h>
-#endif
+#include "absl/status/statusor.h"
 
-#if defined(GRPC_POSIX_SOCKET) || defined(GRPC_CFSTREAM)
-#include <sys/socket.h>
-#endif
+#include <grpc/event_engine/event_engine.h>
 
+#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 #define GRPC_MAX_SOCKADDR_SIZE 128
 
-struct grpc_resolved_address {
-  char addr[GRPC_MAX_SOCKADDR_SIZE];
-  socklen_t len;
-};
-struct grpc_resolved_addresses {
-  size_t naddrs;
-  grpc_resolved_address* addrs;
-};
-
 namespace grpc_core {
 extern const char* kDefaultSecurePort;
 constexpr int kDefaultSecurePortInt = 443;
-}  // namespace grpc_core
+constexpr Duration kDefaultDNSRequestTimeout = Duration::Minutes(2);
+
+// A singleton class used for async and blocking DNS resolution
+class DNSResolver {
+ public:
+  using TaskHandle = ::grpc_event_engine::experimental::EventEngine::
+      DNSResolver::LookupTaskHandle;
+  static constexpr TaskHandle kNullHandle{0, 0};
+
+  virtual ~DNSResolver() {}
+
+  static std::string HandleToString(TaskHandle handle);
+
+  // Asynchronously resolve name. Use \a default_port if a port isn't designated
+  // in \a name, otherwise use the port in \a name. On completion, \a on_done is
+  // invoked with the result.
+  //
+  // Note for implementations: calls may acquire locks in \a on_done which
+  // were previously held while starting the request. Therefore,
+  // implementations must not invoke \a on_done inline from the call site that
+  // starts the request. The DNSCallbackExecCtxScheduler utility may help
+  // address this.
+  //
+  // \a interested_parties may be deleted after a request is cancelled.
+  virtual TaskHandle LookupHostname(
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_resolved,
+      absl::string_view name, absl::string_view default_port, Duration timeout,
+      grpc_pollset_set* interested_parties, absl::string_view name_server) = 0;
+
+  // Resolve name in a blocking fashion. Use \a default_port if a port isn't
+  // designated in \a name, otherwise use the port in \a name.
+  virtual absl::StatusOr<std::vector<grpc_resolved_address>>
+  LookupHostnameBlocking(absl::string_view name,
+                         absl::string_view default_port) = 0;
+
+  // Asynchronously resolve an SRV Record to Hostnames.
+  // On completion, \a on_done is invoked with the result.
+  //
+  // The same caveats in \a LookupHostname apply here as well.
+  //
+  // TODO(hork): return std::vector<SRVRecord> and ask the client to do the
+  // subsequent hostname lookups.
+  virtual TaskHandle LookupSRV(
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_resolved,
+      absl::string_view name, Duration timeout,
+      grpc_pollset_set* interested_parties, absl::string_view name_server) = 0;
+
+  // Asynchronously resolve a TXT Record. On completion, \a on_done is invoked
+  // with the resulting string.
+  //
+  // The same caveats in \a LookupHostname apply here.
+  virtual TaskHandle LookupTXT(
+      std::function<void(absl::StatusOr<std::string>)> on_resolved,
+      absl::string_view name, Duration timeout,
+      grpc_pollset_set* interested_parties, absl::string_view name_server) = 0;
+
+  // This shares the same semantics with \a EventEngine::Cancel: successfully
+  // cancelled lookups will not have their callbacks executed, and this
+  // method returns true. If a TaskHandle is unknown, this method should return
+  // false.
+  virtual bool Cancel(TaskHandle handle) = 0;
+};
+
+// Override the active DNS resolver which should be used for all DNS
+// resolution in gRPC. Note this should only be used during library
+// initialization or within tests.
+void SetDNSResolver(DNSResolver* resolver);
 
-typedef struct grpc_address_resolver_vtable {
-  void (*resolve_address)(const char* addr, const char* default_port,
-                          grpc_pollset_set* interested_parties,
-                          grpc_closure* on_done,
-                          grpc_resolved_addresses** addresses);
-  grpc_error_handle (*blocking_resolve_address)(
-      const char* name, const char* default_port,
-      grpc_resolved_addresses** addresses);
-} grpc_address_resolver_vtable;
-
-void grpc_set_resolver_impl(grpc_address_resolver_vtable* vtable);
-
-/* Asynchronously resolve addr. Use default_port if a port isn't designated
-   in addr, otherwise use the port in addr. */
-/* TODO(apolcyn): add a timeout here */
-void grpc_resolve_address(const char* addr, const char* default_port,
-                          grpc_pollset_set* interested_parties,
-                          grpc_closure* on_done,
-                          grpc_resolved_addresses** addresses);
-
-/* Destroy resolved addresses */
-void grpc_resolved_addresses_destroy(grpc_resolved_addresses* addresses);
-
-/* Resolve addr in a blocking fashion. On success,
-   result must be freed with grpc_resolved_addresses_destroy. */
-grpc_error_handle grpc_blocking_resolve_address(
-    const char* name, const char* default_port,
-    grpc_resolved_addresses** addresses);
+// Get the singleton DNS resolver instance which should be used for all
+// DNS resolution in gRPC.
+DNSResolver* GetDNSResolver();
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_H */

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

@@ -0,0 +1,58 @@
+//
+// 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_RESOLVE_ADDRESS_IMPL_H
+#define GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_IMPL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+namespace grpc_core {
+
+// A fire and forget class to schedule DNS resolution callbacks on the ExecCtx,
+// which is frequently necessary to avoid lock inversion related problems.
+class DNSCallbackExecCtxScheduler {
+ public:
+  DNSCallbackExecCtxScheduler(
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_done,
+      absl::StatusOr<std::vector<grpc_resolved_address>> param)
+      : on_done_(std::move(on_done)), param_(std::move(param)) {
+    GRPC_CLOSURE_INIT(&closure_, RunCallback, this, grpc_schedule_on_exec_ctx);
+    ExecCtx::Run(DEBUG_LOCATION, &closure_, GRPC_ERROR_NONE);
+  }
+
+ private:
+  static void RunCallback(void* arg, grpc_error_handle /* error */) {
+    DNSCallbackExecCtxScheduler* self =
+        static_cast<DNSCallbackExecCtxScheduler*>(arg);
+    self->on_done_(std::move(self->param_));
+    delete self;
+  }
+
+  const std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+      on_done_;
+  absl::StatusOr<std::vector<grpc_resolved_address>> param_;
+  grpc_closure closure_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_IOMGR_RESOLVE_ADDRESS_IMPL_H */