grpc 1.7.3 → 1.8.0

data/src/core/lib/iomgr/ev_posix.c

@@ -1,266 +0,0 @@
-/*
- *
- * 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.
- *
- */
-
-#include "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_POSIX_SOCKET
-
-#include "src/core/lib/iomgr/ev_posix.h"
-
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/useful.h>
-
-#include "src/core/lib/debug/trace.h"
-#include "src/core/lib/iomgr/ev_epoll1_linux.h"
-#include "src/core/lib/iomgr/ev_epollex_linux.h"
-#include "src/core/lib/iomgr/ev_epollsig_linux.h"
-#include "src/core/lib/iomgr/ev_poll_posix.h"
-#include "src/core/lib/support/env.h"
-
-grpc_tracer_flag grpc_polling_trace =
-    GRPC_TRACER_INITIALIZER(false, "polling"); /* Disabled by default */
-
-#ifndef NDEBUG
-grpc_tracer_flag grpc_trace_fd_refcount =
-    GRPC_TRACER_INITIALIZER(false, "fd_refcount");
-#endif
-
-/** Default poll() function - a pointer so that it can be overridden by some
- *  tests */
-grpc_poll_function_type grpc_poll_function = poll;
-
-grpc_wakeup_fd grpc_global_wakeup_fd;
-
-static const grpc_event_engine_vtable *g_event_engine;
-static const char *g_poll_strategy_name = NULL;
-
-typedef const grpc_event_engine_vtable *(*event_engine_factory_fn)(
-    bool explicit_request);
-
-typedef struct {
-  const char *name;
-  event_engine_factory_fn factory;
-} event_engine_factory;
-
-static const event_engine_factory g_factories[] = {
-    {"epoll1", grpc_init_epoll1_linux},
-    {"epollsig", grpc_init_epollsig_linux},
-    {"poll", grpc_init_poll_posix},
-    {"poll-cv", grpc_init_poll_cv_posix},
-    {"epollex", grpc_init_epollex_linux},
-};
-
-static void add(const char *beg, const char *end, char ***ss, size_t *ns) {
-  size_t n = *ns;
-  size_t np = n + 1;
-  char *s;
-  size_t len;
-  GPR_ASSERT(end >= beg);
-  len = (size_t)(end - beg);
-  s = (char *)gpr_malloc(len + 1);
-  memcpy(s, beg, len);
-  s[len] = 0;
-  *ss = (char **)gpr_realloc(*ss, sizeof(char **) * np);
-  (*ss)[n] = s;
-  *ns = np;
-}
-
-static void split(const char *s, char ***ss, size_t *ns) {
-  const char *c = strchr(s, ',');
-  if (c == NULL) {
-    add(s, s + strlen(s), ss, ns);
-  } else {
-    add(s, c, ss, ns);
-    split(c + 1, ss, ns);
-  }
-}
-
-static bool is(const char *want, const char *have) {
-  return 0 == strcmp(want, "all") || 0 == strcmp(want, have);
-}
-
-static void try_engine(const char *engine) {
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(g_factories); i++) {
-    if (is(engine, g_factories[i].name)) {
-      if ((g_event_engine = g_factories[i].factory(
-               0 == strcmp(engine, g_factories[i].name)))) {
-        g_poll_strategy_name = g_factories[i].name;
-        gpr_log(GPR_DEBUG, "Using polling engine: %s", g_factories[i].name);
-        return;
-      }
-    }
-  }
-}
-
-/* This should be used for testing purposes ONLY */
-void grpc_set_event_engine_test_only(
-    const grpc_event_engine_vtable *ev_engine) {
-  g_event_engine = ev_engine;
-}
-
-const grpc_event_engine_vtable *grpc_get_event_engine_test_only() {
-  return g_event_engine;
-}
-
-/* Call this only after calling grpc_event_engine_init() */
-const char *grpc_get_poll_strategy_name() { return g_poll_strategy_name; }
-
-void grpc_event_engine_init(void) {
-  grpc_register_tracer(&grpc_polling_trace);
-
-  char *s = gpr_getenv("GRPC_POLL_STRATEGY");
-  if (s == NULL) {
-    s = gpr_strdup("all");
-  }
-
-  char **strings = NULL;
-  size_t nstrings = 0;
-  split(s, &strings, &nstrings);
-
-  for (size_t i = 0; g_event_engine == NULL && i < nstrings; i++) {
-    try_engine(strings[i]);
-  }
-
-  for (size_t i = 0; i < nstrings; i++) {
-    gpr_free(strings[i]);
-  }
-  gpr_free(strings);
-  gpr_free(s);
-
-  if (g_event_engine == NULL) {
-    gpr_log(GPR_ERROR, "No event engine could be initialized");
-    abort();
-  }
-}
-
-void grpc_event_engine_shutdown(void) {
-  g_event_engine->shutdown_engine();
-  g_event_engine = NULL;
-}
-
-grpc_fd *grpc_fd_create(int fd, const char *name) {
-  return g_event_engine->fd_create(fd, name);
-}
-
-int grpc_fd_wrapped_fd(grpc_fd *fd) {
-  return g_event_engine->fd_wrapped_fd(fd);
-}
-
-void grpc_fd_orphan(grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_closure *on_done,
-                    int *release_fd, bool already_closed, const char *reason) {
-  g_event_engine->fd_orphan(exec_ctx, fd, on_done, release_fd, already_closed,
-                            reason);
-}
-
-void grpc_fd_shutdown(grpc_exec_ctx *exec_ctx, grpc_fd *fd, grpc_error *why) {
-  g_event_engine->fd_shutdown(exec_ctx, fd, why);
-}
-
-bool grpc_fd_is_shutdown(grpc_fd *fd) {
-  return g_event_engine->fd_is_shutdown(fd);
-}
-
-void grpc_fd_notify_on_read(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
-                            grpc_closure *closure) {
-  g_event_engine->fd_notify_on_read(exec_ctx, fd, closure);
-}
-
-void grpc_fd_notify_on_write(grpc_exec_ctx *exec_ctx, grpc_fd *fd,
-                             grpc_closure *closure) {
-  g_event_engine->fd_notify_on_write(exec_ctx, fd, closure);
-}
-
-size_t grpc_pollset_size(void) { return g_event_engine->pollset_size; }
-
-void grpc_pollset_init(grpc_pollset *pollset, gpr_mu **mu) {
-  g_event_engine->pollset_init(pollset, mu);
-}
-
-void grpc_pollset_shutdown(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                           grpc_closure *closure) {
-  g_event_engine->pollset_shutdown(exec_ctx, pollset, closure);
-}
-
-void grpc_pollset_destroy(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset) {
-  g_event_engine->pollset_destroy(exec_ctx, pollset);
-}
-
-grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                              grpc_pollset_worker **worker, gpr_timespec now,
-                              gpr_timespec deadline) {
-  return g_event_engine->pollset_work(exec_ctx, pollset, worker, now, deadline);
-}
-
-grpc_error *grpc_pollset_kick(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                              grpc_pollset_worker *specific_worker) {
-  return g_event_engine->pollset_kick(exec_ctx, pollset, specific_worker);
-}
-
-void grpc_pollset_add_fd(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
-                         struct grpc_fd *fd) {
-  g_event_engine->pollset_add_fd(exec_ctx, pollset, fd);
-}
-
-grpc_pollset_set *grpc_pollset_set_create(void) {
-  return g_event_engine->pollset_set_create();
-}
-
-void grpc_pollset_set_destroy(grpc_exec_ctx *exec_ctx,
-                              grpc_pollset_set *pollset_set) {
-  g_event_engine->pollset_set_destroy(exec_ctx, pollset_set);
-}
-
-void grpc_pollset_set_add_pollset(grpc_exec_ctx *exec_ctx,
-                                  grpc_pollset_set *pollset_set,
-                                  grpc_pollset *pollset) {
-  g_event_engine->pollset_set_add_pollset(exec_ctx, pollset_set, pollset);
-}
-
-void grpc_pollset_set_del_pollset(grpc_exec_ctx *exec_ctx,
-                                  grpc_pollset_set *pollset_set,
-                                  grpc_pollset *pollset) {
-  g_event_engine->pollset_set_del_pollset(exec_ctx, pollset_set, pollset);
-}
-
-void grpc_pollset_set_add_pollset_set(grpc_exec_ctx *exec_ctx,
-                                      grpc_pollset_set *bag,
-                                      grpc_pollset_set *item) {
-  g_event_engine->pollset_set_add_pollset_set(exec_ctx, bag, item);
-}
-
-void grpc_pollset_set_del_pollset_set(grpc_exec_ctx *exec_ctx,
-                                      grpc_pollset_set *bag,
-                                      grpc_pollset_set *item) {
-  g_event_engine->pollset_set_del_pollset_set(exec_ctx, bag, item);
-}
-
-void grpc_pollset_set_add_fd(grpc_exec_ctx *exec_ctx,
-                             grpc_pollset_set *pollset_set, grpc_fd *fd) {
-  g_event_engine->pollset_set_add_fd(exec_ctx, pollset_set, fd);
-}
-
-void grpc_pollset_set_del_fd(grpc_exec_ctx *exec_ctx,
-                             grpc_pollset_set *pollset_set, grpc_fd *fd) {
-  g_event_engine->pollset_set_del_fd(exec_ctx, pollset_set, fd);
-}
-
-#endif  // GRPC_POSIX_SOCKET

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

@@ -1,113 +0,0 @@
-/*
- *
- * 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.
- *
- */
-
-#include "src/core/lib/iomgr/exec_ctx.h"
-
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-#include <grpc/support/thd.h>
-
-#include "src/core/lib/iomgr/combiner.h"
-#include "src/core/lib/profiling/timers.h"
-
-bool grpc_exec_ctx_ready_to_finish(grpc_exec_ctx *exec_ctx) {
-  if ((exec_ctx->flags & GRPC_EXEC_CTX_FLAG_IS_FINISHED) == 0) {
-    if (exec_ctx->check_ready_to_finish(exec_ctx,
-                                        exec_ctx->check_ready_to_finish_arg)) {
-      exec_ctx->flags |= GRPC_EXEC_CTX_FLAG_IS_FINISHED;
-      return true;
-    }
-    return false;
-  } else {
-    return true;
-  }
-}
-
-bool grpc_never_ready_to_finish(grpc_exec_ctx *exec_ctx, void *arg_ignored) {
-  return false;
-}
-
-bool grpc_always_ready_to_finish(grpc_exec_ctx *exec_ctx, void *arg_ignored) {
-  return true;
-}
-
-bool grpc_exec_ctx_has_work(grpc_exec_ctx *exec_ctx) {
-  return exec_ctx->active_combiner != NULL ||
-         !grpc_closure_list_empty(exec_ctx->closure_list);
-}
-
-void grpc_exec_ctx_finish(grpc_exec_ctx *exec_ctx) {
-  exec_ctx->flags |= GRPC_EXEC_CTX_FLAG_IS_FINISHED;
-  grpc_exec_ctx_flush(exec_ctx);
-}
-
-static void exec_ctx_run(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
-                         grpc_error *error) {
-#ifndef NDEBUG
-  closure->scheduled = false;
-  if (GRPC_TRACER_ON(grpc_trace_closure)) {
-    gpr_log(GPR_DEBUG, "running closure %p: created [%s:%d]: %s [%s:%d]",
-            closure, closure->file_created, closure->line_created,
-            closure->run ? "run" : "scheduled", closure->file_initiated,
-            closure->line_initiated);
-  }
-#endif
-  closure->cb(exec_ctx, closure->cb_arg, error);
-#ifndef NDEBUG
-  if (GRPC_TRACER_ON(grpc_trace_closure)) {
-    gpr_log(GPR_DEBUG, "closure %p finished", closure);
-  }
-#endif
-  GRPC_ERROR_UNREF(error);
-}
-
-bool grpc_exec_ctx_flush(grpc_exec_ctx *exec_ctx) {
-  bool did_something = 0;
-  GPR_TIMER_BEGIN("grpc_exec_ctx_flush", 0);
-  for (;;) {
-    if (!grpc_closure_list_empty(exec_ctx->closure_list)) {
-      grpc_closure *c = exec_ctx->closure_list.head;
-      exec_ctx->closure_list.head = exec_ctx->closure_list.tail = NULL;
-      while (c != NULL) {
-        grpc_closure *next = c->next_data.next;
-        grpc_error *error = c->error_data.error;
-        did_something = true;
-        exec_ctx_run(exec_ctx, c, error);
-        c = next;
-      }
-    } else if (!grpc_combiner_continue_exec_ctx(exec_ctx)) {
-      break;
-    }
-  }
-  GPR_ASSERT(exec_ctx->active_combiner == NULL);
-  GPR_TIMER_END("grpc_exec_ctx_flush", 0);
-  return did_something;
-}
-
-static void exec_ctx_sched(grpc_exec_ctx *exec_ctx, grpc_closure *closure,
-                           grpc_error *error) {
-  grpc_closure_list_append(&exec_ctx->closure_list, closure, error);
-}
-
-void grpc_exec_ctx_global_init(void) {}
-void grpc_exec_ctx_global_shutdown(void) {}
-
-static const grpc_closure_scheduler_vtable exec_ctx_scheduler_vtable = {
-    exec_ctx_run, exec_ctx_sched, "exec_ctx"};
-static grpc_closure_scheduler exec_ctx_scheduler = {&exec_ctx_scheduler_vtable};
-grpc_closure_scheduler *grpc_schedule_on_exec_ctx = &exec_ctx_scheduler;

data/src/core/lib/iomgr/tcp_uv.c

@@ -1,381 +0,0 @@
-/*
- *
- * Copyright 2016 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 "src/core/lib/iomgr/port.h"
-
-#ifdef GRPC_UV
-
-#include <limits.h>
-#include <string.h>
-
-#include <grpc/slice_buffer.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/iomgr_uv.h"
-#include "src/core/lib/iomgr/network_status_tracker.h"
-#include "src/core/lib/iomgr/resource_quota.h"
-#include "src/core/lib/iomgr/tcp_uv.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/support/string.h"
-
-grpc_tracer_flag grpc_tcp_trace = GRPC_TRACER_INITIALIZER(false, "tcp");
-
-typedef struct {
-  grpc_endpoint base;
-  gpr_refcount refcount;
-
-  uv_write_t write_req;
-  uv_shutdown_t shutdown_req;
-
-  uv_tcp_t *handle;
-
-  grpc_closure *read_cb;
-  grpc_closure *write_cb;
-
-  grpc_slice read_slice;
-  grpc_slice_buffer *read_slices;
-  grpc_slice_buffer *write_slices;
-  uv_buf_t *write_buffers;
-
-  grpc_resource_user *resource_user;
-
-  bool shutting_down;
-
-  char *peer_string;
-  grpc_pollset *pollset;
-} grpc_tcp;
-
-static void tcp_free(grpc_exec_ctx *exec_ctx, grpc_tcp *tcp) {
-  grpc_slice_unref_internal(exec_ctx, tcp->read_slice);
-  grpc_resource_user_unref(exec_ctx, tcp->resource_user);
-  gpr_free(tcp->handle);
-  gpr_free(tcp->peer_string);
-  gpr_free(tcp);
-}
-
-#ifndef NDEBUG
-#define TCP_UNREF(exec_ctx, tcp, reason) \
-  tcp_unref((exec_ctx), (tcp), (reason), __FILE__, __LINE__)
-#define TCP_REF(tcp, reason) tcp_ref((tcp), (reason), __FILE__, __LINE__)
-static void tcp_unref(grpc_exec_ctx *exec_ctx, grpc_tcp *tcp,
-                      const char *reason, const char *file, int line) {
-  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
-    gpr_atm val = gpr_atm_no_barrier_load(&tcp->refcount.count);
-    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "TCP unref %p : %s %" PRIdPTR " -> %" PRIdPTR, tcp, reason, val,
-            val - 1);
-  }
-  if (gpr_unref(&tcp->refcount)) {
-    tcp_free(exec_ctx, tcp);
-  }
-}
-
-static void tcp_ref(grpc_tcp *tcp, const char *reason, const char *file,
-                    int line) {
-  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
-    gpr_atm val = gpr_atm_no_barrier_load(&tcp->refcount.count);
-    gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
-            "TCP   ref %p : %s %" PRIdPTR " -> %" PRIdPTR, tcp, reason, val,
-            val + 1);
-  }
-  gpr_ref(&tcp->refcount);
-}
-#else
-#define TCP_UNREF(exec_ctx, tcp, reason) tcp_unref((exec_ctx), (tcp))
-#define TCP_REF(tcp, reason) tcp_ref((tcp))
-static void tcp_unref(grpc_exec_ctx *exec_ctx, grpc_tcp *tcp) {
-  if (gpr_unref(&tcp->refcount)) {
-    tcp_free(exec_ctx, tcp);
-  }
-}
-
-static void tcp_ref(grpc_tcp *tcp) { gpr_ref(&tcp->refcount); }
-#endif
-
-static void uv_close_callback(uv_handle_t *handle) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_tcp *tcp = handle->data;
-  TCP_UNREF(&exec_ctx, tcp, "destroy");
-  grpc_exec_ctx_finish(&exec_ctx);
-}
-
-static grpc_slice alloc_read_slice(grpc_exec_ctx *exec_ctx,
-                                   grpc_resource_user *resource_user) {
-  return grpc_resource_user_slice_malloc(exec_ctx, resource_user,
-                                         GRPC_TCP_DEFAULT_READ_SLICE_SIZE);
-}
-
-static void alloc_uv_buf(uv_handle_t *handle, size_t suggested_size,
-                         uv_buf_t *buf) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_tcp *tcp = handle->data;
-  (void)suggested_size;
-  buf->base = (char *)GRPC_SLICE_START_PTR(tcp->read_slice);
-  buf->len = GRPC_SLICE_LENGTH(tcp->read_slice);
-  grpc_exec_ctx_finish(&exec_ctx);
-}
-
-static void read_callback(uv_stream_t *stream, ssize_t nread,
-                          const uv_buf_t *buf) {
-  grpc_slice sub;
-  grpc_error *error;
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_tcp *tcp = stream->data;
-  grpc_closure *cb = tcp->read_cb;
-  if (nread == 0) {
-    // Nothing happened. Wait for the next callback
-    return;
-  }
-  TCP_UNREF(&exec_ctx, tcp, "read");
-  tcp->read_cb = NULL;
-  // TODO(murgatroid99): figure out what the return value here means
-  uv_read_stop(stream);
-  if (nread == UV_EOF) {
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("EOF");
-  } else if (nread > 0) {
-    // Successful read
-    sub = grpc_slice_sub_no_ref(tcp->read_slice, 0, (size_t)nread);
-    grpc_slice_buffer_add(tcp->read_slices, sub);
-    tcp->read_slice = alloc_read_slice(&exec_ctx, tcp->resource_user);
-    error = GRPC_ERROR_NONE;
-    if (GRPC_TRACER_ON(grpc_tcp_trace)) {
-      size_t i;
-      const char *str = grpc_error_string(error);
-      gpr_log(GPR_DEBUG, "read: error=%s", str);
-
-      for (i = 0; i < tcp->read_slices->count; i++) {
-        char *dump = grpc_dump_slice(tcp->read_slices->slices[i],
-                                     GPR_DUMP_HEX | GPR_DUMP_ASCII);
-        gpr_log(GPR_DEBUG, "READ %p (peer=%s): %s", tcp, tcp->peer_string,
-                dump);
-        gpr_free(dump);
-      }
-    }
-  } else {
-    // nread < 0: Error
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("TCP Read failed");
-  }
-  GRPC_CLOSURE_SCHED(&exec_ctx, cb, error);
-  grpc_exec_ctx_finish(&exec_ctx);
-}
-
-static void uv_endpoint_read(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                             grpc_slice_buffer *read_slices, grpc_closure *cb) {
-  grpc_tcp *tcp = (grpc_tcp *)ep;
-  int status;
-  grpc_error *error = GRPC_ERROR_NONE;
-  GRPC_UV_ASSERT_SAME_THREAD();
-  GPR_ASSERT(tcp->read_cb == NULL);
-  tcp->read_cb = cb;
-  tcp->read_slices = read_slices;
-  grpc_slice_buffer_reset_and_unref_internal(exec_ctx, read_slices);
-  TCP_REF(tcp, "read");
-  // TODO(murgatroid99): figure out what the return value here means
-  status =
-      uv_read_start((uv_stream_t *)tcp->handle, alloc_uv_buf, read_callback);
-  if (status != 0) {
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("TCP Read failed at start");
-    error =
-        grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR,
-                           grpc_slice_from_static_string(uv_strerror(status)));
-    GRPC_CLOSURE_SCHED(exec_ctx, cb, error);
-  }
-  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
-    const char *str = grpc_error_string(error);
-    gpr_log(GPR_DEBUG, "Initiating read on %p: error=%s", tcp, str);
-  }
-}
-
-static void write_callback(uv_write_t *req, int status) {
-  grpc_tcp *tcp = req->data;
-  grpc_error *error;
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_closure *cb = tcp->write_cb;
-  tcp->write_cb = NULL;
-  TCP_UNREF(&exec_ctx, tcp, "write");
-  if (status == 0) {
-    error = GRPC_ERROR_NONE;
-  } else {
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("TCP Write failed");
-  }
-  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
-    const char *str = grpc_error_string(error);
-    gpr_log(GPR_DEBUG, "write complete on %p: error=%s", tcp, str);
-  }
-  gpr_free(tcp->write_buffers);
-  grpc_resource_user_free(&exec_ctx, tcp->resource_user,
-                          sizeof(uv_buf_t) * tcp->write_slices->count);
-  GRPC_CLOSURE_SCHED(&exec_ctx, cb, error);
-  grpc_exec_ctx_finish(&exec_ctx);
-}
-
-static void uv_endpoint_write(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                              grpc_slice_buffer *write_slices,
-                              grpc_closure *cb) {
-  grpc_tcp *tcp = (grpc_tcp *)ep;
-  uv_buf_t *buffers;
-  unsigned int buffer_count;
-  unsigned int i;
-  grpc_slice *slice;
-  uv_write_t *write_req;
-  GRPC_UV_ASSERT_SAME_THREAD();
-
-  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
-    size_t j;
-
-    for (j = 0; j < write_slices->count; j++) {
-      char *data = grpc_dump_slice(write_slices->slices[j],
-                                   GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_DEBUG, "WRITE %p (peer=%s): %s", tcp, tcp->peer_string, data);
-      gpr_free(data);
-    }
-  }
-
-  if (tcp->shutting_down) {
-    GRPC_CLOSURE_SCHED(exec_ctx, cb, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-                                         "TCP socket is shutting down"));
-    return;
-  }
-
-  GPR_ASSERT(tcp->write_cb == NULL);
-  tcp->write_slices = write_slices;
-  GPR_ASSERT(tcp->write_slices->count <= UINT_MAX);
-  if (tcp->write_slices->count == 0) {
-    // No slices means we don't have to do anything,
-    // and libuv doesn't like empty writes
-    GRPC_CLOSURE_SCHED(exec_ctx, cb, GRPC_ERROR_NONE);
-    return;
-  }
-
-  tcp->write_cb = cb;
-  buffer_count = (unsigned int)tcp->write_slices->count;
-  buffers = gpr_malloc(sizeof(uv_buf_t) * buffer_count);
-  grpc_resource_user_alloc(exec_ctx, tcp->resource_user,
-                           sizeof(uv_buf_t) * buffer_count, NULL);
-  for (i = 0; i < buffer_count; i++) {
-    slice = &tcp->write_slices->slices[i];
-    buffers[i].base = (char *)GRPC_SLICE_START_PTR(*slice);
-    buffers[i].len = GRPC_SLICE_LENGTH(*slice);
-  }
-  tcp->write_buffers = buffers;
-  write_req = &tcp->write_req;
-  write_req->data = tcp;
-  TCP_REF(tcp, "write");
-  // TODO(murgatroid99): figure out what the return value here means
-  uv_write(write_req, (uv_stream_t *)tcp->handle, buffers, buffer_count,
-           write_callback);
-}
-
-static void uv_add_to_pollset(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                              grpc_pollset *pollset) {
-  // No-op. We're ignoring pollsets currently
-  (void)exec_ctx;
-  (void)ep;
-  (void)pollset;
-  grpc_tcp *tcp = (grpc_tcp *)ep;
-  tcp->pollset = pollset;
-}
-
-static void uv_add_to_pollset_set(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                                  grpc_pollset_set *pollset) {
-  // No-op. We're ignoring pollsets currently
-  (void)exec_ctx;
-  (void)ep;
-  (void)pollset;
-}
-
-static void shutdown_callback(uv_shutdown_t *req, int status) {}
-
-static void uv_endpoint_shutdown(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep,
-                                 grpc_error *why) {
-  grpc_tcp *tcp = (grpc_tcp *)ep;
-  if (!tcp->shutting_down) {
-    if (GRPC_TRACER_ON(grpc_tcp_trace)) {
-      const char *str = grpc_error_string(why);
-      gpr_log(GPR_DEBUG, "TCP %p shutdown why=%s", tcp->handle, str);
-    }
-    tcp->shutting_down = true;
-    uv_shutdown_t *req = &tcp->shutdown_req;
-    uv_shutdown(req, (uv_stream_t *)tcp->handle, shutdown_callback);
-    grpc_resource_user_shutdown(exec_ctx, tcp->resource_user);
-  }
-  GRPC_ERROR_UNREF(why);
-}
-
-static void uv_destroy(grpc_exec_ctx *exec_ctx, grpc_endpoint *ep) {
-  grpc_network_status_unregister_endpoint(ep);
-  grpc_tcp *tcp = (grpc_tcp *)ep;
-  uv_close((uv_handle_t *)tcp->handle, uv_close_callback);
-}
-
-static char *uv_get_peer(grpc_endpoint *ep) {
-  grpc_tcp *tcp = (grpc_tcp *)ep;
-  return gpr_strdup(tcp->peer_string);
-}
-
-static grpc_resource_user *uv_get_resource_user(grpc_endpoint *ep) {
-  grpc_tcp *tcp = (grpc_tcp *)ep;
-  return tcp->resource_user;
-}
-
-static int uv_get_fd(grpc_endpoint *ep) { return -1; }
-
-static grpc_endpoint_vtable vtable = {
-    uv_endpoint_read,      uv_endpoint_write,    uv_add_to_pollset,
-    uv_add_to_pollset_set, uv_endpoint_shutdown, uv_destroy,
-    uv_get_resource_user,  uv_get_peer,          uv_get_fd};
-
-grpc_endpoint *grpc_tcp_create(uv_tcp_t *handle,
-                               grpc_resource_quota *resource_quota,
-                               char *peer_string) {
-  grpc_tcp *tcp = (grpc_tcp *)gpr_malloc(sizeof(grpc_tcp));
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-
-  if (GRPC_TRACER_ON(grpc_tcp_trace)) {
-    gpr_log(GPR_DEBUG, "Creating TCP endpoint %p", tcp);
-  }
-
-  /* Disable Nagle's Algorithm */
-  uv_tcp_nodelay(handle, 1);
-
-  memset(tcp, 0, sizeof(grpc_tcp));
-  tcp->base.vtable = &vtable;
-  tcp->handle = handle;
-  handle->data = tcp;
-  gpr_ref_init(&tcp->refcount, 1);
-  tcp->peer_string = gpr_strdup(peer_string);
-  tcp->shutting_down = false;
-  tcp->resource_user = grpc_resource_user_create(resource_quota, peer_string);
-  tcp->read_slice = alloc_read_slice(&exec_ctx, tcp->resource_user);
-  /* Tell network status tracking code about the new endpoint */
-  grpc_network_status_register_endpoint(&tcp->base);
-
-#ifndef GRPC_UV_TCP_HOLD_LOOP
-  uv_unref((uv_handle_t *)handle);
-#endif
-
-  grpc_exec_ctx_finish(&exec_ctx);
-  return &tcp->base;
-}
-
-#endif /* GRPC_UV */