grpc 1.15.0 → 1.30.0

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

@@ -31,10 +31,22 @@
 #include "src/core/lib/iomgr/socket_factory_posix.h"
 #include "src/core/lib/iomgr/socket_mutator.h"
 
+#ifdef GRPC_LINUX_ERRQUEUE
+#ifndef SO_ZEROCOPY
+#define SO_ZEROCOPY 60
+#endif
+#ifndef SO_EE_ORIGIN_ZEROCOPY
+#define SO_EE_ORIGIN_ZEROCOPY 5
+#endif
+#endif /* ifdef GRPC_LINUX_ERRQUEUE */
+
 /* a wrapper for accept or accept4 */
 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);
+
 /* set a socket to non blocking mode */
 grpc_error* grpc_set_socket_nonblocking(int fd, int non_blocking);
 
@@ -53,6 +65,13 @@ grpc_error* grpc_set_socket_low_latency(int fd, int low_latency);
 /* set SO_REUSEPORT */
 grpc_error* 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(
+    int fd, const grpc_channel_args* channel_args, bool is_client);
+
 /* Returns true if this system can create AF_INET6 sockets bound to ::1.
    The value is probed once, and cached for the life of the process.
 
@@ -84,6 +103,10 @@ grpc_error* 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);
 
+/* 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);
+
 /* An enum to keep track of IPv4/IPv6 socket modes.
 
    Currently, this information is only used when a socket is first created, but
@@ -103,6 +126,9 @@ typedef enum grpc_dualstack_mode {
 /* Only tests should use this flag. */
 extern int grpc_forbid_dualstack_sockets_for_testing;
 
+/* Tries to set the socket to dualstack. Returns 1 on success. */
+int grpc_set_socket_dualstack(int fd);
+
 /* Creates a new socket for connecting to (or listening on) an address.
 
    If addr is AF_INET6, this creates an IPv6 socket first.  If that fails,

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

@@ -39,6 +39,8 @@
 #include "src/core/lib/iomgr/sockaddr_windows.h"
 #include "src/core/lib/iomgr/socket_windows.h"
 
+static DWORD s_wsa_socket_flags;
+
 grpc_winsocket* grpc_winsocket_create(SOCKET socket, const char* name) {
   char* final_name;
   grpc_winsocket* r = (grpc_winsocket*)gpr_malloc(sizeof(grpc_winsocket));
@@ -122,7 +124,7 @@ static void socket_notify_on_iocp(grpc_winsocket* socket, grpc_closure* closure,
   gpr_mu_lock(&socket->state_mu);
   if (info->has_pending_iocp) {
     info->has_pending_iocp = 0;
-    GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
   } else {
     info->closure = closure;
   }
@@ -143,7 +145,7 @@ void grpc_socket_become_ready(grpc_winsocket* socket,
   GPR_ASSERT(!info->has_pending_iocp);
   gpr_mu_lock(&socket->state_mu);
   if (info->closure) {
-    GRPC_CLOSURE_SCHED(info->closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, info->closure, GRPC_ERROR_NONE);
     info->closure = NULL;
   } else {
     info->has_pending_iocp = 1;
@@ -181,4 +183,21 @@ int grpc_ipv6_loopback_available(void) {
   return g_ipv6_loopback_available;
 }
 
+DWORD grpc_get_default_wsa_socket_flags() { return s_wsa_socket_flags; }
+
+void grpc_wsa_socket_flags_init() {
+  s_wsa_socket_flags = WSA_FLAG_OVERLAPPED;
+  /* WSA_FLAG_NO_HANDLE_INHERIT may be not supported on the older Windows
+     versions, see
+     https://msdn.microsoft.com/en-us/library/windows/desktop/ms742212(v=vs.85).aspx
+     for details. */
+  SOCKET sock = WSASocket(AF_INET6, SOCK_STREAM, IPPROTO_TCP, NULL, 0,
+                          s_wsa_socket_flags | WSA_FLAG_NO_HANDLE_INHERIT);
+  if (sock != INVALID_SOCKET) {
+    /* Windows 7, Windows 2008 R2 with SP1 or later */
+    s_wsa_socket_flags |= WSA_FLAG_NO_HANDLE_INHERIT;
+    closesocket(sock);
+  }
+}
+
 #endif /* GRPC_WINSOCK_SOCKET */

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

@@ -32,6 +32,10 @@
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 
+#ifndef WSA_FLAG_NO_HANDLE_INHERIT
+#define WSA_FLAG_NO_HANDLE_INHERIT 0x80
+#endif
+
 /* This holds the data for an outstanding read or write on a socket.
    The mutex to protect the concurrent access to that data is the one
    inside the winsocket wrapper. */
@@ -55,7 +59,7 @@ typedef struct grpc_winsocket_callback_info {
      to hold a mutex for a long amount of time. */
   int has_pending_iocp;
   /* The results of the overlapped operation. */
-  DWORD bytes_transfered;
+  DWORD bytes_transferred;
   int wsa_error;
 } grpc_winsocket_callback_info;
 
@@ -114,6 +118,10 @@ void grpc_socket_become_ready(grpc_winsocket* winsocket,
    The value is probed once, and cached for the life of the process. */
 int grpc_ipv6_loopback_available(void);
 
+void grpc_wsa_socket_flags_init();
+
+DWORD grpc_get_default_wsa_socket_flags();
+
 #endif
 
 #endif /* GRPC_CORE_LIB_IOMGR_SOCKET_WINDOWS_H */

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

@@ -0,0 +1,215 @@
+
+/*
+ *
+ * Copyright 2018 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>
+
+#include "src/core/lib/iomgr/port.h"
+
+#ifdef GRPC_CFSTREAM_CLIENT
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+
+#include <netinet/in.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"
+#include "src/core/lib/iomgr/closure.h"
+#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"
+
+extern grpc_core::TraceFlag grpc_tcp_trace;
+
+typedef struct CFStreamConnect {
+  gpr_mu mu;
+  gpr_refcount refcount;
+
+  CFReadStreamRef read_stream;
+  CFWriteStreamRef write_stream;
+  CFStreamHandle* stream_handle;
+
+  grpc_timer alarm;
+  grpc_closure on_alarm;
+  grpc_closure on_open;
+
+  bool read_stream_open;
+  bool write_stream_open;
+  bool failed;
+
+  grpc_closure* closure;
+  grpc_endpoint** endpoint;
+  int refs;
+  char* addr_name;
+  grpc_resource_quota* resource_quota;
+} CFStreamConnect;
+
+static void CFStreamConnectCleanup(CFStreamConnect* connect) {
+  grpc_resource_quota_unref_internal(connect->resource_quota);
+  CFSTREAM_HANDLE_UNREF(connect->stream_handle, "async connect clean up");
+  CFRelease(connect->read_stream);
+  CFRelease(connect->write_stream);
+  gpr_mu_destroy(&connect->mu);
+  gpr_free(connect->addr_name);
+  gpr_free(connect);
+}
+
+static void OnAlarm(void* arg, grpc_error* error) {
+  CFStreamConnect* connect = static_cast<CFStreamConnect*>(arg);
+  if (grpc_tcp_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnAlarm, error:%p", connect, error);
+  }
+  gpr_mu_lock(&connect->mu);
+  grpc_closure* closure = connect->closure;
+  connect->closure = nil;
+  const bool done = (--connect->refs == 0);
+  gpr_mu_unlock(&connect->mu);
+  // Only schedule a callback once, by either OnAlarm or OnOpen. The
+  // first one issues callback while the second one does cleanup.
+  if (done) {
+    CFStreamConnectCleanup(connect);
+  } else {
+    grpc_error* 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) {
+  CFStreamConnect* connect = static_cast<CFStreamConnect*>(arg);
+  if (grpc_tcp_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "CLIENT_CONNECT :%p OnOpen, error:%p", connect, error);
+  }
+  gpr_mu_lock(&connect->mu);
+  grpc_timer_cancel(&connect->alarm);
+  grpc_closure* closure = connect->closure;
+  connect->closure = nil;
+
+  bool done = (--connect->refs == 0);
+  grpc_endpoint** endpoint = connect->endpoint;
+
+  // Only schedule a callback once, by either OnAlarm or OnOpen. The
+  // first one issues callback while the second one does cleanup.
+  if (done) {
+    gpr_mu_unlock(&connect->mu);
+    CFStreamConnectCleanup(connect);
+  } else {
+    if (error == GRPC_ERROR_NONE) {
+      CFErrorRef stream_error = CFReadStreamCopyError(connect->read_stream);
+      if (stream_error == NULL) {
+        stream_error = CFWriteStreamCopyError(connect->write_stream);
+      }
+      if (stream_error) {
+        error = GRPC_ERROR_CREATE_FROM_CFERROR(stream_error, "connect() error");
+        CFRelease(stream_error);
+      }
+      if (error == GRPC_ERROR_NONE) {
+        *endpoint = grpc_cfstream_endpoint_create(
+            connect->read_stream, connect->write_stream, connect->addr_name,
+            connect->resource_quota, connect->stream_handle);
+      }
+    } else {
+      GRPC_ERROR_REF(error);
+    }
+    gpr_mu_unlock(&connect->mu);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
+  }
+}
+
+static void ParseResolvedAddress(const grpc_resolved_address* addr,
+                                 CFStringRef* host, int* port) {
+  std::string host_port = grpc_sockaddr_to_string(addr, true);
+  std::string host_string;
+  std::string port_string;
+  grpc_core::SplitHostPort(host_port, &host_string, &port_string);
+  *host = CFStringCreateWithCString(NULL, host_string.c_str(),
+                                    kCFStringEncodingUTF8);
+  *port = grpc_sockaddr_get_port(addr);
+}
+
+static void CFStreamClientConnect(grpc_closure* closure, grpc_endpoint** ep,
+                                  grpc_pollset_set* interested_parties,
+                                  const grpc_channel_args* channel_args,
+                                  const grpc_resolved_address* resolved_addr,
+                                  grpc_millis deadline) {
+  CFStreamConnect* connect;
+
+  connect = (CFStreamConnect*)gpr_zalloc(sizeof(CFStreamConnect));
+  connect->closure = closure;
+  connect->endpoint = ep;
+  connect->addr_name = grpc_sockaddr_to_uri(resolved_addr);
+  // connect->resource_quota = resource_quota;
+  connect->refs = 2;  // One for the connect operation, one for the timer.
+  gpr_ref_init(&connect->refcount, 1);
+  gpr_mu_init(&connect->mu);
+
+  if (grpc_tcp_trace.enabled()) {
+    gpr_log(GPR_DEBUG, "CLIENT_CONNECT: %p, %s: asynchronously connecting",
+            connect, connect->addr_name);
+  }
+
+  grpc_resource_quota* resource_quota = grpc_resource_quota_create(NULL);
+  if (channel_args != NULL) {
+    for (size_t i = 0; i < channel_args->num_args; i++) {
+      if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_RESOURCE_QUOTA)) {
+        grpc_resource_quota_unref_internal(resource_quota);
+        resource_quota = grpc_resource_quota_ref_internal(
+            (grpc_resource_quota*)channel_args->args[i].value.pointer.p);
+      }
+    }
+  }
+  connect->resource_quota = resource_quota;
+
+  CFReadStreamRef read_stream;
+  CFWriteStreamRef write_stream;
+
+  CFStringRef host;
+  int port;
+  ParseResolvedAddress(resolved_addr, &host, &port);
+  CFStreamCreatePairWithSocketToHost(NULL, host, port, &read_stream,
+                                     &write_stream);
+  CFRelease(host);
+  connect->read_stream = read_stream;
+  connect->write_stream = write_stream;
+  connect->stream_handle =
+      CFStreamHandle::CreateStreamHandle(read_stream, write_stream);
+  GRPC_CLOSURE_INIT(&connect->on_open, OnOpen, static_cast<void*>(connect),
+                    grpc_schedule_on_exec_ctx);
+  connect->stream_handle->NotifyOnOpen(&connect->on_open);
+  GRPC_CLOSURE_INIT(&connect->on_alarm, OnAlarm, connect,
+                    grpc_schedule_on_exec_ctx);
+  gpr_mu_lock(&connect->mu);
+  CFReadStreamOpen(read_stream);
+  CFWriteStreamOpen(write_stream);
+  grpc_timer_init(&connect->alarm, deadline, &connect->on_alarm);
+  gpr_mu_unlock(&connect->mu);
+}
+
+grpc_tcp_client_vtable grpc_cfstream_client_vtable = {CFStreamClientConnect};
+
+#endif /* GRPC_CFSTREAM_CLIENT */

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

@@ -58,13 +58,13 @@ static void custom_tcp_connect_cleanup(grpc_custom_tcp_connect* connect) {
   }
 }
 
-static void custom_close_callback(grpc_custom_socket* socket) {}
+static void custom_close_callback(grpc_custom_socket* /*socket*/) {}
 
 static void on_alarm(void* acp, grpc_error* error) {
   int done;
   grpc_custom_socket* socket = (grpc_custom_socket*)acp;
   grpc_custom_tcp_connect* connect = socket->connector;
-  if (grpc_tcp_trace.enabled()) {
+  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, str);
@@ -81,9 +81,8 @@ static void on_alarm(void* acp, grpc_error* error) {
   }
 }
 
-static void custom_connect_callback(grpc_custom_socket* socket,
-                                    grpc_error* error) {
-  grpc_core::ExecCtx exec_ctx;
+static void custom_connect_callback_internal(grpc_custom_socket* socket,
+                                             grpc_error* error) {
   grpc_custom_tcp_connect* connect = socket->connector;
   int done;
   grpc_closure* closure = connect->closure;
@@ -97,7 +96,20 @@ static void custom_connect_callback(grpc_custom_socket* socket,
     grpc_core::ExecCtx::Get()->Flush();
     custom_tcp_connect_cleanup(connect);
   }
-  GRPC_CLOSURE_SCHED(closure, error);
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
+}
+
+static void custom_connect_callback(grpc_custom_socket* socket,
+                                    grpc_error* 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
+     * yet, we should create one. */
+    grpc_core::ExecCtx exec_ctx;
+    custom_connect_callback_internal(socket, error);
+  } else {
+    custom_connect_callback_internal(socket, error);
+  }
 }
 
 static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
@@ -135,7 +147,7 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
   socket->listener = nullptr;
   connect->refs = 2;
 
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %p %s: asynchronously connecting",
             socket, connect->addr_name);
   }

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

@@ -49,7 +49,7 @@
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
 
-typedef struct {
+struct async_connect {
   gpr_mu mu;
   grpc_fd* fd;
   grpc_timer alarm;
@@ -61,8 +61,7 @@ typedef struct {
   grpc_endpoint** ep;
   grpc_closure* closure;
   grpc_channel_args* channel_args;
-} async_connect;
-
+};
 static grpc_error* prepare_socket(const grpc_resolved_address* addr, int fd,
                                   const grpc_channel_args* channel_args) {
   grpc_error* err = GRPC_ERROR_NONE;
@@ -76,20 +75,18 @@ static grpc_error* prepare_socket(const grpc_resolved_address* addr, int fd,
   if (!grpc_is_unix_socket(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
     if (err != GRPC_ERROR_NONE) goto error;
+    err = grpc_set_socket_reuse_addr(fd, 1);
+    if (err != GRPC_ERROR_NONE) goto error;
+    err = grpc_set_socket_tcp_user_timeout(fd, channel_args,
+                                           true /* is_client */);
+    if (err != GRPC_ERROR_NONE) goto error;
   }
   err = grpc_set_socket_no_sigpipe_if_possible(fd);
   if (err != GRPC_ERROR_NONE) goto error;
-  if (channel_args) {
-    for (size_t i = 0; i < channel_args->num_args; i++) {
-      if (0 == strcmp(channel_args->args[i].key, GRPC_ARG_SOCKET_MUTATOR)) {
-        GPR_ASSERT(channel_args->args[i].type == GRPC_ARG_POINTER);
-        grpc_socket_mutator* mutator = static_cast<grpc_socket_mutator*>(
-            channel_args->args[i].value.pointer.p);
-        err = grpc_set_socket_with_mutator(fd, mutator);
-        if (err != GRPC_ERROR_NONE) goto error;
-      }
-    }
-  }
+
+  err = grpc_apply_socket_mutator_in_args(fd, channel_args);
+  if (err != GRPC_ERROR_NONE) goto error;
+
   goto done;
 
 error:
@@ -103,7 +100,7 @@ done:
 static void tc_on_alarm(void* acp, grpc_error* error) {
   int done;
   async_connect* ac = static_cast<async_connect*>(acp);
-  if (grpc_tcp_trace.enabled()) {
+  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,
             str);
@@ -140,7 +137,7 @@ static void on_writable(void* acp, grpc_error* error) {
 
   GRPC_ERROR_REF(error);
 
-  if (grpc_tcp_trace.enabled()) {
+  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,
             str);
@@ -243,19 +240,16 @@ finish:
     grpc_channel_args_destroy(ac->channel_args);
     gpr_free(ac);
   }
-  GRPC_CLOSURE_SCHED(closure, error);
+  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,
-                                       grpc_fd** fdobj) {
+                                       int* fd) {
   grpc_dualstack_mode dsmode;
-  int fd;
   grpc_error* error;
-  char* name;
-  char* addr_str;
-  *fdobj = nullptr;
+  *fd = -1;
   /* Use dualstack sockets where available. Set mapped to v6 or v4 mapped to
      v6. */
   if (!grpc_sockaddr_to_v4mapped(addr, mapped_addr)) {
@@ -263,7 +257,7 @@ grpc_error* grpc_tcp_client_prepare_fd(const grpc_channel_args* channel_args,
     memcpy(mapped_addr, addr, sizeof(*mapped_addr));
   }
   error =
-      grpc_create_dualstack_socket(mapped_addr, SOCK_STREAM, 0, &dsmode, &fd);
+      grpc_create_dualstack_socket(mapped_addr, SOCK_STREAM, 0, &dsmode, fd);
   if (error != GRPC_ERROR_NONE) {
     return error;
   }
@@ -273,39 +267,47 @@ grpc_error* grpc_tcp_client_prepare_fd(const grpc_channel_args* channel_args,
       memcpy(mapped_addr, addr, sizeof(*mapped_addr));
     }
   }
-  if ((error = prepare_socket(mapped_addr, fd, channel_args)) !=
+  if ((error = prepare_socket(mapped_addr, *fd, channel_args)) !=
       GRPC_ERROR_NONE) {
     return error;
   }
-  addr_str = grpc_sockaddr_to_uri(mapped_addr);
-  gpr_asprintf(&name, "tcp-client:%s", addr_str);
-  *fdobj = grpc_fd_create(fd, name, false);
-  gpr_free(name);
-  gpr_free(addr_str);
   return GRPC_ERROR_NONE;
 }
 
 void grpc_tcp_client_create_from_prepared_fd(
-    grpc_pollset_set* interested_parties, grpc_closure* closure, grpc_fd* fdobj,
+    grpc_pollset_set* interested_parties, grpc_closure* closure, const int fd,
     const grpc_channel_args* channel_args, const grpc_resolved_address* addr,
     grpc_millis deadline, grpc_endpoint** ep) {
-  const int fd = grpc_fd_wrapped_fd(fdobj);
   int err;
   async_connect* ac;
   do {
     err = connect(fd, reinterpret_cast<const grpc_sockaddr*>(addr->addr),
                   addr->len);
   } while (err < 0 && errno == EINTR);
+
+  char* name;
+  char* addr_str;
+  addr_str = grpc_sockaddr_to_uri(addr);
+  gpr_asprintf(&name, "tcp-client:%s", addr_str);
+  grpc_fd* fdobj = grpc_fd_create(fd, name, true);
+  gpr_free(name);
+  gpr_free(addr_str);
+
   if (err >= 0) {
     char* addr_str = grpc_sockaddr_to_uri(addr);
     *ep = grpc_tcp_client_create_from_fd(fdobj, channel_args, addr_str);
     gpr_free(addr_str);
-    GRPC_CLOSURE_SCHED(closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
     return;
   }
   if (errno != EWOULDBLOCK && errno != EINPROGRESS) {
+    grpc_error* error = GRPC_OS_ERROR(errno, "connect");
+    char* addr_str = grpc_sockaddr_to_uri(addr);
+    error = grpc_error_set_str(error, GRPC_ERROR_STR_TARGET_ADDRESS,
+                               grpc_slice_from_copied_string(addr_str));
+    gpr_free(addr_str);
     grpc_fd_orphan(fdobj, nullptr, nullptr, "tcp_client_connect_error");
-    GRPC_CLOSURE_SCHED(closure, GRPC_OS_ERROR(errno, "connect"));
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return;
   }
 
@@ -323,7 +325,7 @@ void grpc_tcp_client_create_from_prepared_fd(
                     grpc_schedule_on_exec_ctx);
   ac->channel_args = grpc_channel_args_copy(channel_args);
 
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
     gpr_log(GPR_INFO, "CLIENT_CONNECT: %s: asynchronously connecting fd %p",
             ac->addr_str, fdobj);
   }
@@ -341,15 +343,15 @@ static void tcp_connect(grpc_closure* closure, grpc_endpoint** ep,
                         const grpc_resolved_address* addr,
                         grpc_millis deadline) {
   grpc_resolved_address mapped_addr;
-  grpc_fd* fdobj = nullptr;
+  int fd = -1;
   grpc_error* error;
   *ep = nullptr;
   if ((error = grpc_tcp_client_prepare_fd(channel_args, addr, &mapped_addr,
-                                          &fdobj)) != GRPC_ERROR_NONE) {
-    GRPC_CLOSURE_SCHED(closure, error);
+                                          &fd)) != GRPC_ERROR_NONE) {
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, closure, error);
     return;
   }
-  grpc_tcp_client_create_from_prepared_fd(interested_parties, closure, fdobj,
+  grpc_tcp_client_create_from_prepared_fd(interested_parties, closure, fd,
                                           channel_args, &mapped_addr, deadline,
                                           ep);
 }