grpc 1.35.0 → 1.38.0

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

@@ -132,7 +132,7 @@ struct grpc_resource_quota {
      scaled to the range [0..RESOURCE_USAGE_ESTIMATION_MAX] */
   gpr_atm memory_usage_estimation;
 
-  /* Master combiner lock: all activity on a quota executes under this combiner
+  /* Main combiner lock: all activity on a quota executes under this combiner
    * (so no mutex is needed for this data structure) */
   grpc_core::Combiner* combiner;
   /* Size of the resource quota */
@@ -276,7 +276,7 @@ static bool rq_reclaim_from_per_user_free_pool(
     grpc_resource_quota* resource_quota);
 static bool rq_reclaim(grpc_resource_quota* resource_quota, bool destructive);
 
-static void rq_step(void* rq, grpc_error* /*error*/) {
+static void rq_step(void* rq, grpc_error_handle /*error*/) {
   grpc_resource_quota* resource_quota = static_cast<grpc_resource_quota*>(rq);
   resource_quota->step_scheduled = false;
   do {
@@ -484,7 +484,7 @@ static grpc_slice ru_slice_create(grpc_resource_user* resource_user,
  * the combiner
  */
 
-static void ru_allocate(void* ru, grpc_error* /*error*/) {
+static void ru_allocate(void* ru, grpc_error_handle /*error*/) {
   grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (rulist_empty(resource_user->resource_quota,
                    GRPC_RULIST_AWAITING_ALLOCATION)) {
@@ -493,7 +493,7 @@ static void ru_allocate(void* ru, grpc_error* /*error*/) {
   rulist_add_tail(resource_user, GRPC_RULIST_AWAITING_ALLOCATION);
 }
 
-static void ru_add_to_free_pool(void* ru, grpc_error* /*error*/) {
+static void ru_add_to_free_pool(void* ru, grpc_error_handle /*error*/) {
   grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (!rulist_empty(resource_user->resource_quota,
                     GRPC_RULIST_AWAITING_ALLOCATION) &&
@@ -518,7 +518,7 @@ static bool ru_post_reclaimer(grpc_resource_user* resource_user,
   return true;
 }
 
-static void ru_post_benign_reclaimer(void* ru, grpc_error* /*error*/) {
+static void ru_post_benign_reclaimer(void* ru, grpc_error_handle /*error*/) {
   grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (!ru_post_reclaimer(resource_user, false)) return;
   if (!rulist_empty(resource_user->resource_quota,
@@ -532,7 +532,8 @@ static void ru_post_benign_reclaimer(void* ru, grpc_error* /*error*/) {
   rulist_add_tail(resource_user, GRPC_RULIST_RECLAIMER_BENIGN);
 }
 
-static void ru_post_destructive_reclaimer(void* ru, grpc_error* /*error*/) {
+static void ru_post_destructive_reclaimer(void* ru,
+                                          grpc_error_handle /*error*/) {
   grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   if (!ru_post_reclaimer(resource_user, true)) return;
   if (!rulist_empty(resource_user->resource_quota,
@@ -548,7 +549,7 @@ static void ru_post_destructive_reclaimer(void* ru, grpc_error* /*error*/) {
   rulist_add_tail(resource_user, GRPC_RULIST_RECLAIMER_DESTRUCTIVE);
 }
 
-static void ru_shutdown(void* ru, grpc_error* /*error*/) {
+static void ru_shutdown(void* ru, grpc_error_handle /*error*/) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_resource_quota_trace)) {
     gpr_log(GPR_INFO, "RU shutdown %p", ru);
   }
@@ -568,7 +569,7 @@ static void ru_shutdown(void* ru, grpc_error* /*error*/) {
   gpr_mu_unlock(&resource_user->mu);
 }
 
-static void ru_destroy(void* ru, grpc_error* /*error*/) {
+static void ru_destroy(void* ru, grpc_error_handle /*error*/) {
   grpc_resource_user* resource_user = static_cast<grpc_resource_user*>(ru);
   GPR_ASSERT(gpr_atm_no_barrier_load(&resource_user->refs) == 0);
   // Free all the remaining thread quota
@@ -601,7 +602,7 @@ static void ru_alloc_slices(
   }
 }
 
-static void ru_allocated_slices(void* arg, grpc_error* error) {
+static void ru_allocated_slices(void* arg, grpc_error_handle error) {
   grpc_resource_user_slice_allocator* slice_allocator =
       static_cast<grpc_resource_user_slice_allocator*>(arg);
   if (error == GRPC_ERROR_NONE) ru_alloc_slices(slice_allocator);
@@ -619,7 +620,7 @@ struct rq_resize_args {
   grpc_resource_quota* resource_quota;
   grpc_closure closure;
 };
-static void rq_resize(void* args, grpc_error* /*error*/) {
+static void rq_resize(void* args, grpc_error_handle /*error*/) {
   rq_resize_args* a = static_cast<rq_resize_args*>(args);
   int64_t delta = a->size - a->resource_quota->size;
   a->resource_quota->size += delta;
@@ -630,7 +631,7 @@ static void rq_resize(void* args, grpc_error* /*error*/) {
   gpr_free(a);
 }
 
-static void rq_reclamation_done(void* rq, grpc_error* /*error*/) {
+static void rq_reclamation_done(void* rq, grpc_error_handle /*error*/) {
   grpc_resource_quota* resource_quota = static_cast<grpc_resource_quota*>(rq);
   resource_quota->reclaiming = false;
   rq_step_sched(resource_quota);

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

@@ -47,13 +47,13 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 
 /* set a socket to use zerocopy */
-grpc_error* grpc_set_socket_zerocopy(int fd) {
+grpc_error_handle grpc_set_socket_zerocopy(int fd) {
 #ifdef GRPC_LINUX_ERRQUEUE
   const int enable = 1;
   auto err = setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &enable, sizeof(enable));
@@ -62,12 +62,13 @@ grpc_error* grpc_set_socket_zerocopy(int fd) {
   }
   return GRPC_ERROR_NONE;
 #else
+  (void)fd;
   return GRPC_OS_ERROR(ENOSYS, "setsockopt(SO_ZEROCOPY)");
 #endif
 }
 
 /* set a socket to non blocking mode */
-grpc_error* grpc_set_socket_nonblocking(int fd, int non_blocking) {
+grpc_error_handle grpc_set_socket_nonblocking(int fd, int non_blocking) {
   int oldflags = fcntl(fd, F_GETFL, 0);
   if (oldflags < 0) {
     return GRPC_OS_ERROR(errno, "fcntl");
@@ -86,7 +87,7 @@ grpc_error* grpc_set_socket_nonblocking(int fd, int non_blocking) {
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_set_socket_no_sigpipe_if_possible(int fd) {
+grpc_error_handle grpc_set_socket_no_sigpipe_if_possible(int fd) {
 #ifdef GRPC_HAVE_SO_NOSIGPIPE
   int val = 1;
   int newval;
@@ -107,7 +108,7 @@ grpc_error* grpc_set_socket_no_sigpipe_if_possible(int fd) {
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_set_socket_ip_pktinfo_if_possible(int fd) {
+grpc_error_handle grpc_set_socket_ip_pktinfo_if_possible(int fd) {
   // Use conditionally-important parameter to avoid warning
   (void)fd;
 #ifdef GRPC_HAVE_IP_PKTINFO
@@ -120,7 +121,7 @@ grpc_error* grpc_set_socket_ip_pktinfo_if_possible(int fd) {
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_set_socket_ipv6_recvpktinfo_if_possible(int fd) {
+grpc_error_handle grpc_set_socket_ipv6_recvpktinfo_if_possible(int fd) {
   // Use conditionally-important parameter to avoid warning
   (void)fd;
 #ifdef GRPC_HAVE_IPV6_RECVPKTINFO
@@ -133,14 +134,14 @@ grpc_error* grpc_set_socket_ipv6_recvpktinfo_if_possible(int fd) {
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_set_socket_sndbuf(int fd, int buffer_size_bytes) {
+grpc_error_handle grpc_set_socket_sndbuf(int fd, int buffer_size_bytes) {
   return 0 == setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &buffer_size_bytes,
                          sizeof(buffer_size_bytes))
              ? GRPC_ERROR_NONE
              : GRPC_OS_ERROR(errno, "setsockopt(SO_SNDBUF)");
 }
 
-grpc_error* grpc_set_socket_rcvbuf(int fd, int buffer_size_bytes) {
+grpc_error_handle grpc_set_socket_rcvbuf(int fd, int buffer_size_bytes) {
   return 0 == setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &buffer_size_bytes,
                          sizeof(buffer_size_bytes))
              ? GRPC_ERROR_NONE
@@ -148,7 +149,7 @@ grpc_error* grpc_set_socket_rcvbuf(int fd, int buffer_size_bytes) {
 }
 
 /* set a socket to close on exec */
-grpc_error* grpc_set_socket_cloexec(int fd, int close_on_exec) {
+grpc_error_handle grpc_set_socket_cloexec(int fd, int close_on_exec) {
   int oldflags = fcntl(fd, F_GETFD, 0);
   if (oldflags < 0) {
     return GRPC_OS_ERROR(errno, "fcntl");
@@ -168,7 +169,7 @@ grpc_error* grpc_set_socket_cloexec(int fd, int close_on_exec) {
 }
 
 /* set a socket to reuse old addresses */
-grpc_error* grpc_set_socket_reuse_addr(int fd, int reuse) {
+grpc_error_handle grpc_set_socket_reuse_addr(int fd, int reuse) {
   int val = (reuse != 0);
   int newval;
   socklen_t intlen = sizeof(newval);
@@ -186,7 +187,7 @@ grpc_error* grpc_set_socket_reuse_addr(int fd, int reuse) {
 }
 
 /* set a socket to reuse old addresses */
-grpc_error* grpc_set_socket_reuse_port(int fd, int reuse) {
+grpc_error_handle grpc_set_socket_reuse_port(int fd, int reuse) {
 #ifndef SO_REUSEPORT
   return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
       "SO_REUSEPORT unavailable on compiling system");
@@ -231,7 +232,7 @@ bool grpc_is_socket_reuse_port_supported() {
 }
 
 /* disable nagle */
-grpc_error* grpc_set_socket_low_latency(int fd, int low_latency) {
+grpc_error_handle grpc_set_socket_low_latency(int fd, int low_latency) {
   int val = (low_latency != 0);
   int newval;
   socklen_t intlen = sizeof(newval);
@@ -296,7 +297,7 @@ void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client) {
 }
 
 /* Set TCP_USER_TIMEOUT */
-grpc_error* grpc_set_socket_tcp_user_timeout(
+grpc_error_handle grpc_set_socket_tcp_user_timeout(
     int fd, const grpc_channel_args* channel_args, bool is_client) {
   // Use conditionally-important parameter to avoid warning
   (void)fd;
@@ -387,7 +388,8 @@ grpc_error* grpc_set_socket_tcp_user_timeout(
 }
 
 /* set a socket using a grpc_socket_mutator */
-grpc_error* grpc_set_socket_with_mutator(int fd, grpc_socket_mutator* mutator) {
+grpc_error_handle grpc_set_socket_with_mutator(int fd,
+                                               grpc_socket_mutator* mutator) {
   GPR_ASSERT(mutator);
   if (!grpc_socket_mutator_mutate_fd(mutator, fd)) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("grpc_socket_mutator failed.");
@@ -395,8 +397,8 @@ grpc_error* grpc_set_socket_with_mutator(int fd, grpc_socket_mutator* mutator) {
   return GRPC_ERROR_NONE;
 }
 
-grpc_error* grpc_apply_socket_mutator_in_args(int fd,
-                                              const grpc_channel_args* args) {
+grpc_error_handle grpc_apply_socket_mutator_in_args(
+    int fd, const grpc_channel_args* args) {
   const grpc_arg* socket_mutator_arg =
       grpc_channel_args_find(args, GRPC_ARG_SOCKET_MUTATOR);
   if (socket_mutator_arg == nullptr) {
@@ -436,16 +438,17 @@ int grpc_ipv6_loopback_available(void) {
   return g_ipv6_loopback_available;
 }
 
-static grpc_error* error_for_fd(int fd, const grpc_resolved_address* addr) {
+static grpc_error_handle error_for_fd(int fd,
+                                      const grpc_resolved_address* addr) {
   if (fd >= 0) return GRPC_ERROR_NONE;
   std::string addr_str = grpc_sockaddr_to_string(addr, false);
-  grpc_error* err = grpc_error_set_str(
+  grpc_error_handle err = grpc_error_set_str(
       GRPC_OS_ERROR(errno, "socket"), GRPC_ERROR_STR_TARGET_ADDRESS,
       grpc_slice_from_copied_string(addr_str.c_str()));
   return err;
 }
 
-grpc_error* grpc_create_dualstack_socket(
+grpc_error_handle grpc_create_dualstack_socket(
     const grpc_resolved_address* resolved_addr, int type, int protocol,
     grpc_dualstack_mode* dsmode, int* newfd) {
   return grpc_create_dualstack_socket_using_factory(
@@ -459,7 +462,7 @@ static int create_socket(grpc_socket_factory* factory, int domain, int type,
              : socket(domain, type, protocol);
 }
 
-grpc_error* grpc_create_dualstack_socket_using_factory(
+grpc_error_handle grpc_create_dualstack_socket_using_factory(
     grpc_socket_factory* factory, const grpc_resolved_address* resolved_addr,
     int type, int protocol, grpc_dualstack_mode* dsmode, int* newfd) {
   const grpc_sockaddr* addr =

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

@@ -45,31 +45,31 @@ int grpc_accept4(int sockfd, grpc_resolved_address* resolved_addr, int nonblock,
                  int cloexec);
 
 /* set a socket to use zerocopy */
-grpc_error* grpc_set_socket_zerocopy(int fd);
+grpc_error_handle grpc_set_socket_zerocopy(int fd);
 
 /* set a socket to non blocking mode */
-grpc_error* grpc_set_socket_nonblocking(int fd, int non_blocking);
+grpc_error_handle grpc_set_socket_nonblocking(int fd, int non_blocking);
 
 /* set a socket to close on exec */
-grpc_error* grpc_set_socket_cloexec(int fd, int close_on_exec);
+grpc_error_handle grpc_set_socket_cloexec(int fd, int close_on_exec);
 
 /* set a socket to reuse old addresses */
-grpc_error* grpc_set_socket_reuse_addr(int fd, int reuse);
+grpc_error_handle grpc_set_socket_reuse_addr(int fd, int reuse);
 
 /* return true if SO_REUSEPORT is supported */
 bool grpc_is_socket_reuse_port_supported();
 
 /* disable nagle */
-grpc_error* grpc_set_socket_low_latency(int fd, int low_latency);
+grpc_error_handle grpc_set_socket_low_latency(int fd, int low_latency);
 
 /* set SO_REUSEPORT */
-grpc_error* grpc_set_socket_reuse_port(int fd, int reuse);
+grpc_error_handle grpc_set_socket_reuse_port(int fd, int reuse);
 
 /* Configure the default values for TCP_USER_TIMEOUT */
 void config_default_tcp_user_timeout(bool enable, int timeout, bool is_client);
 
 /* Set TCP_USER_TIMEOUT */
-grpc_error* grpc_set_socket_tcp_user_timeout(
+grpc_error_handle grpc_set_socket_tcp_user_timeout(
     int fd, const grpc_channel_args* channel_args, bool is_client);
 
 /* Returns true if this system can create AF_INET6 sockets bound to ::1.
@@ -84,28 +84,29 @@ int grpc_ipv6_loopback_available(void);
 
 /* Tries to set SO_NOSIGPIPE if available on this platform.
    If SO_NO_SIGPIPE is not available, returns 1. */
-grpc_error* grpc_set_socket_no_sigpipe_if_possible(int fd);
+grpc_error_handle grpc_set_socket_no_sigpipe_if_possible(int fd);
 
 /* Tries to set IP_PKTINFO if available on this platform.
    If IP_PKTINFO is not available, returns 1. */
-grpc_error* grpc_set_socket_ip_pktinfo_if_possible(int fd);
+grpc_error_handle grpc_set_socket_ip_pktinfo_if_possible(int fd);
 
 /* Tries to set IPV6_RECVPKTINFO if available on this platform.
    If IPV6_RECVPKTINFO is not available, returns 1. */
-grpc_error* grpc_set_socket_ipv6_recvpktinfo_if_possible(int fd);
+grpc_error_handle grpc_set_socket_ipv6_recvpktinfo_if_possible(int fd);
 
 /* Tries to set the socket's send buffer to given size. */
-grpc_error* grpc_set_socket_sndbuf(int fd, int buffer_size_bytes);
+grpc_error_handle grpc_set_socket_sndbuf(int fd, int buffer_size_bytes);
 
 /* Tries to set the socket's receive buffer to given size. */
-grpc_error* grpc_set_socket_rcvbuf(int fd, int buffer_size_bytes);
+grpc_error_handle grpc_set_socket_rcvbuf(int fd, int buffer_size_bytes);
 
 /* Tries to set the socket using a grpc_socket_mutator */
-grpc_error* grpc_set_socket_with_mutator(int fd, grpc_socket_mutator* mutator);
+grpc_error_handle grpc_set_socket_with_mutator(int fd,
+                                               grpc_socket_mutator* mutator);
 
 /* Extracts the first socket mutator from args if any and applies on the fd. */
-grpc_error* grpc_apply_socket_mutator_in_args(int fd,
-                                              const grpc_channel_args* args);
+grpc_error_handle grpc_apply_socket_mutator_in_args(
+    int fd, const grpc_channel_args* args);
 
 /* An enum to keep track of IPv4/IPv6 socket modes.
 
@@ -149,14 +150,13 @@ int grpc_set_socket_dualstack(int fd);
      IPv4, so that bind() or connect() see the correct family.
    Also, it's important to distinguish between DUALSTACK and IPV6 when
    listening on the [::] wildcard address. */
-grpc_error* grpc_create_dualstack_socket(const grpc_resolved_address* addr,
-                                         int type, int protocol,
-                                         grpc_dualstack_mode* dsmode,
-                                         int* newfd);
+grpc_error_handle grpc_create_dualstack_socket(
+    const grpc_resolved_address* addr, int type, int protocol,
+    grpc_dualstack_mode* dsmode, int* newfd);
 
 /* Same as grpc_create_dualstack_socket(), but use the given socket factory (if
    non-null) to create the socket, rather than calling socket() directly. */
-grpc_error* grpc_create_dualstack_socket_using_factory(
+grpc_error_handle grpc_create_dualstack_socket_using_factory(
     grpc_socket_factory* factory, const grpc_resolved_address* addr, int type,
     int protocol, grpc_dualstack_mode* dsmode, int* newfd);
 

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

@@ -33,6 +33,7 @@
 
 #include <netinet/in.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/cfstream_handle.h"
@@ -40,7 +41,6 @@
 #include "src/core/lib/iomgr/endpoint_cfstream.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/error_cfstream.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/timer.h"
 
@@ -78,7 +78,7 @@ static void CFStreamConnectCleanup(CFStreamConnect* connect) {
   delete connect;
 }
 
-static void OnAlarm(void* arg, grpc_error* error) {
+static void OnAlarm(void* arg, grpc_error_handle error) {
   CFStreamConnect* connect = static_cast<CFStreamConnect*>(arg);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnAlarm, error:%p", connect, error);
@@ -93,13 +93,13 @@ static void OnAlarm(void* arg, grpc_error* error) {
   if (done) {
     CFStreamConnectCleanup(connect);
   } else {
-    grpc_error* error =
+    grpc_error_handle error =
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("connect() timed out");
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
   }
 }
 
-static void OnOpen(void* arg, grpc_error* error) {
+static void OnOpen(void* arg, grpc_error_handle error) {
   CFStreamConnect* connect = static_cast<CFStreamConnect*>(arg);
   if (grpc_tcp_trace.enabled()) {
     gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnOpen, error:%p", connect, error);

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

@@ -25,9 +25,9 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/iomgr_custom.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_custom.h"
 #include "src/core/lib/iomgr/timer.h"
@@ -59,14 +59,13 @@ static void custom_tcp_connect_cleanup(grpc_custom_tcp_connect* connect) {
 
 static void custom_close_callback(grpc_custom_socket* /*socket*/) {}
 
-static void on_alarm(void* acp, grpc_error* error) {
+static void on_alarm(void* acp, grpc_error_handle error) {
   int done;
   grpc_custom_socket* socket = static_cast<grpc_custom_socket*>(acp);
   grpc_custom_tcp_connect* connect = socket->connector;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    const char* str = grpc_error_string(error);
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_alarm: error=%s",
-            connect->addr_name.c_str(), str);
+            connect->addr_name.c_str(), grpc_error_std_string(error).c_str());
   }
   if (error == GRPC_ERROR_NONE) {
     /* error == NONE implies that the timer ran out, and wasn't cancelled. If
@@ -81,7 +80,7 @@ static void on_alarm(void* acp, grpc_error* error) {
 }
 
 static void custom_connect_callback_internal(grpc_custom_socket* socket,
-                                             grpc_error* error) {
+                                             grpc_error_handle error) {
   grpc_custom_tcp_connect* connect = socket->connector;
   int done;
   grpc_closure* closure = connect->closure;
@@ -99,7 +98,7 @@ static void custom_connect_callback_internal(grpc_custom_socket* socket,
 }
 
 static void custom_connect_callback(grpc_custom_socket* socket,
-                                    grpc_error* error) {
+                                    grpc_error_handle error) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   if (grpc_core::ExecCtx::Get() == nullptr) {
     /* If we are being run on a thread which does not have an exec_ctx created

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

@@ -35,12 +35,12 @@
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/ev_posix.h"
-#include "src/core/lib/iomgr/iomgr_posix.h"
+#include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/sockaddr.h"
-#include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/tcp_posix.h"
@@ -64,9 +64,10 @@ struct async_connect {
   grpc_channel_args* channel_args;
 };
 
-static grpc_error* prepare_socket(const grpc_resolved_address* addr, int fd,
-                                  const grpc_channel_args* channel_args) {
-  grpc_error* err = GRPC_ERROR_NONE;
+static grpc_error_handle prepare_socket(const grpc_resolved_address* addr,
+                                        int fd,
+                                        const grpc_channel_args* channel_args) {
+  grpc_error_handle err = GRPC_ERROR_NONE;
 
   GPR_ASSERT(fd >= 0);
 
@@ -99,13 +100,12 @@ done:
   return err;
 }
 
-static void tc_on_alarm(void* acp, grpc_error* error) {
+static void tc_on_alarm(void* acp, grpc_error_handle error) {
   int done;
   async_connect* ac = static_cast<async_connect*>(acp);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    const char* str = grpc_error_string(error);
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_alarm: error=%s",
-            ac->addr_str.c_str(), str);
+            ac->addr_str.c_str(), grpc_error_std_string(error).c_str());
   }
   gpr_mu_lock(&ac->mu);
   if (ac->fd != nullptr) {
@@ -126,7 +126,7 @@ grpc_endpoint* grpc_tcp_client_create_from_fd(
   return grpc_tcp_create(fd, channel_args, addr_str);
 }
 
-static void on_writable(void* acp, grpc_error* error) {
+static void on_writable(void* acp, grpc_error_handle error) {
   async_connect* ac = static_cast<async_connect*>(acp);
   int so_error = 0;
   socklen_t so_error_size;
@@ -139,9 +139,8 @@ static void on_writable(void* acp, grpc_error* error) {
   GRPC_ERROR_REF(error);
 
   if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
-    const char* str = grpc_error_string(error);
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: on_writable: error=%s",
-            ac->addr_str.c_str(), str);
+            ac->addr_str.c_str(), grpc_error_std_string(error).c_str());
   }
 
   gpr_mu_lock(&ac->mu);
@@ -242,12 +241,11 @@ finish:
   grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
 }
 
-grpc_error* grpc_tcp_client_prepare_fd(const grpc_channel_args* channel_args,
-                                       const grpc_resolved_address* addr,
-                                       grpc_resolved_address* mapped_addr,
-                                       int* fd) {
+grpc_error_handle grpc_tcp_client_prepare_fd(
+    const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
+    grpc_resolved_address* mapped_addr, int* fd) {
   grpc_dualstack_mode dsmode;
-  grpc_error* error;
+  grpc_error_handle error;
   *fd = -1;
   /* Use dualstack sockets where available. Set mapped to v6 or v4 mapped to
      v6. */
@@ -293,7 +291,7 @@ void grpc_tcp_client_create_from_prepared_fd(
     return;
   }
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
-    grpc_error* error = GRPC_OS_ERROR(errno, "connect");
+    grpc_error_handle error = GRPC_OS_ERROR(errno, "connect");
     error = grpc_error_set_str(
         error, GRPC_ERROR_STR_TARGET_ADDRESS,
         grpc_slice_from_cpp_string(grpc_sockaddr_to_uri(addr)));
@@ -335,7 +333,7 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
                         grpc_millis deadline) {
   grpc_resolved_address mapped_addr;
   int fd = -1;
-  grpc_error* error;
+  grpc_error_handle error;
   *ep = nullptr;
   if ((error = grpc_tcp_client_prepare_fd(channel_args, addr, &mapped_addr,
                                           &fd)) != GRPC_ERROR_NONE) {