grpc 1.18.0 → 1.19.0.pre1

data/src/core/ext/transport/chttp2/transport/flow_control.cc

@@ -111,7 +111,7 @@ void FlowControlTrace::Finish() {
     saw_str = gpr_leftpad("", ' ', kTracePadding);
   }
   gpr_log(GPR_DEBUG,
-          "%p[%u][%s] | %s | trw:%s, ttw:%s, taw:%s, srw:%s, slw:%s, saw:%s",
+          "%p[%u][%s] | %s | trw:%s, tlw:%s, taw:%s, srw:%s, slw:%s, saw:%s",
           tfc_, sfc_ != nullptr ? sfc_->stream()->id : 0,
           tfc_->transport()->is_client ? "cli" : "svr", reason_, trw_str,
           tlw_str, taw_str, srw_str, slw_str, saw_str);

data/src/core/ext/transport/chttp2/transport/frame_window_update.cc

@@ -88,8 +88,9 @@ grpc_error* grpc_chttp2_window_update_parser_parse(void* parser,
   }
 
   if (p->byte == 4) {
-    uint32_t received_update = p->amount;
-    if (received_update == 0 || (received_update & 0x80000000u)) {
+    // top bit is reserved and must be ignored.
+    uint32_t received_update = p->amount & 0x7fffffffu;
+    if (received_update == 0) {
       char* msg;
       gpr_asprintf(&msg, "invalid window update bytes: %d", p->amount);
       grpc_error* err = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);

data/src/core/ext/transport/chttp2/transport/hpack_encoder.cc

@@ -59,7 +59,7 @@
 static grpc_slice_refcount terminal_slice_refcount = {nullptr, nullptr};
 static const grpc_slice terminal_slice = {
     &terminal_slice_refcount, /* refcount */
-    {{nullptr, 0}}            /* data.refcounted */
+    {{0, nullptr}}            /* data.refcounted */
 };
 
 typedef struct {

data/src/core/ext/transport/chttp2/transport/writing.cc

@@ -363,7 +363,6 @@ class DataSendContext {
     grpc_chttp2_encode_data(s_->id, &s_->compressed_data_buffer, send_bytes,
                             is_last_frame_, &s_->stats.outgoing, &t_->outbuf);
     s_->flow_control->SentData(send_bytes);
-    s_->byte_counter += send_bytes;
     if (s_->compressed_data_buffer.length == 0) {
       s_->sending_bytes += s_->uncompressed_data_size;
     }
@@ -498,9 +497,6 @@ class StreamWriteContext {
         data_send_context.CompressMoreBytes();
       }
     }
-    if (s_->traced && grpc_endpoint_can_track_err(t_->ep)) {
-      grpc_core::ContextList::Append(&t_->cl, s_);
-    }
     write_context_->ResetPingClock();
     if (data_send_context.is_last_frame()) {
       SentLastFrame();
@@ -610,11 +606,18 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
      (according to available window sizes) and add to the output buffer */
   while (grpc_chttp2_stream* s = ctx.NextStream()) {
     StreamWriteContext stream_ctx(&ctx, s);
+    size_t orig_len = t->outbuf.length;
     stream_ctx.FlushInitialMetadata();
     stream_ctx.FlushWindowUpdates();
     stream_ctx.FlushData();
     stream_ctx.FlushTrailingMetadata();
-
+    if (t->outbuf.length > orig_len) {
+      /* Add this stream to the list of the contexts to be traced at TCP */
+      s->byte_counter += t->outbuf.length - orig_len;
+      if (s->traced && grpc_endpoint_can_track_err(t->ep)) {
+        grpc_core::ContextList::Append(&t->cl, s);
+      }
+    }
     if (stream_ctx.stream_became_writable()) {
       if (!grpc_chttp2_list_add_writing_stream(t, s)) {
         /* already in writing list: drop ref */

data/src/core/lib/channel/handshaker.cc

@@ -30,302 +30,229 @@
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-grpc_core::TraceFlag grpc_handshaker_trace(false, "handshaker");
+namespace grpc_core {
 
-//
-// grpc_handshaker
-//
+TraceFlag grpc_handshaker_trace(false, "handshaker");
 
-void grpc_handshaker_init(const grpc_handshaker_vtable* vtable,
-                          grpc_handshaker* handshaker) {
-  handshaker->vtable = vtable;
-}
-
-void grpc_handshaker_destroy(grpc_handshaker* handshaker) {
-  handshaker->vtable->destroy(handshaker);
-}
-
-void grpc_handshaker_shutdown(grpc_handshaker* handshaker, grpc_error* why) {
-  handshaker->vtable->shutdown(handshaker, why);
-}
-
-void grpc_handshaker_do_handshake(grpc_handshaker* handshaker,
-                                  grpc_tcp_server_acceptor* acceptor,
-                                  grpc_closure* on_handshake_done,
-                                  grpc_handshaker_args* args) {
-  handshaker->vtable->do_handshake(handshaker, acceptor, on_handshake_done,
-                                   args);
-}
+namespace {
 
-const char* grpc_handshaker_name(grpc_handshaker* handshaker) {
-  return handshaker->vtable->name;
+char* HandshakerArgsString(HandshakerArgs* args) {
+  char* args_str = grpc_channel_args_string(args->args);
+  size_t num_args = args->args != nullptr ? args->args->num_args : 0;
+  size_t read_buffer_length =
+      args->read_buffer != nullptr ? args->read_buffer->length : 0;
+  char* str;
+  gpr_asprintf(&str,
+               "{endpoint=%p, args=%p {size=%" PRIuPTR
+               ": %s}, read_buffer=%p (length=%" PRIuPTR "), exit_early=%d}",
+               args->endpoint, args->args, num_args, args_str,
+               args->read_buffer, read_buffer_length, args->exit_early);
+  gpr_free(args_str);
+  return str;
 }
 
-//
-// grpc_handshake_manager
-//
+}  // namespace
 
-struct grpc_handshake_manager {
-  gpr_mu mu;
-  gpr_refcount refs;
-  bool shutdown;
-  // An array of handshakers added via grpc_handshake_manager_add().
-  size_t count;
-  grpc_handshaker** handshakers;
-  // The index of the handshaker to invoke next and closure to invoke it.
-  size_t index;
-  grpc_closure call_next_handshaker;
-  // The acceptor to call the handshakers with.
-  grpc_tcp_server_acceptor* acceptor;
-  // Deadline timer across all handshakers.
-  grpc_timer deadline_timer;
-  grpc_closure on_timeout;
-  // The final callback and user_data to invoke after the last handshaker.
-  grpc_closure on_handshake_done;
-  void* user_data;
-  // Handshaker args.
-  grpc_handshaker_args args;
-  // Links to the previous and next managers in a list of all pending handshakes
-  // Used at server side only.
-  grpc_handshake_manager* prev;
-  grpc_handshake_manager* next;
-};
+HandshakeManager::HandshakeManager() { gpr_mu_init(&mu_); }
 
-grpc_handshake_manager* grpc_handshake_manager_create() {
-  grpc_handshake_manager* mgr = static_cast<grpc_handshake_manager*>(
-      gpr_zalloc(sizeof(grpc_handshake_manager)));
-  gpr_mu_init(&mgr->mu);
-  gpr_ref_init(&mgr->refs, 1);
-  return mgr;
-}
-
-void grpc_handshake_manager_pending_list_add(grpc_handshake_manager** head,
-                                             grpc_handshake_manager* mgr) {
-  GPR_ASSERT(mgr->prev == nullptr);
-  GPR_ASSERT(mgr->next == nullptr);
-  mgr->next = *head;
+/// Add \a mgr to the server side list of all pending handshake managers, the
+/// list starts with \a *head.
+// Not thread-safe. Caller needs to synchronize.
+void HandshakeManager::AddToPendingMgrList(HandshakeManager** head) {
+  GPR_ASSERT(prev_ == nullptr);
+  GPR_ASSERT(next_ == nullptr);
+  next_ = *head;
   if (*head) {
-    (*head)->prev = mgr;
+    (*head)->prev_ = this;
   }
-  *head = mgr;
+  *head = this;
 }
 
-void grpc_handshake_manager_pending_list_remove(grpc_handshake_manager** head,
-                                                grpc_handshake_manager* mgr) {
-  if (mgr->next != nullptr) {
-    mgr->next->prev = mgr->prev;
+/// Remove \a mgr from the server side list of all pending handshake managers.
+// Not thread-safe. Caller needs to synchronize.
+void HandshakeManager::RemoveFromPendingMgrList(HandshakeManager** head) {
+  if (next_ != nullptr) {
+    next_->prev_ = prev_;
   }
-  if (mgr->prev != nullptr) {
-    mgr->prev->next = mgr->next;
+  if (prev_ != nullptr) {
+    prev_->next_ = next_;
   } else {
-    GPR_ASSERT(*head == mgr);
-    *head = mgr->next;
+    GPR_ASSERT(*head == this);
+    *head = next_;
   }
 }
 
-void grpc_handshake_manager_pending_list_shutdown_all(
-    grpc_handshake_manager* head, grpc_error* why) {
+/// Shutdown all pending handshake managers starting at head on the server
+/// side. Not thread-safe. Caller needs to synchronize.
+void HandshakeManager::ShutdownAllPending(grpc_error* why) {
+  auto* head = this;
   while (head != nullptr) {
-    grpc_handshake_manager_shutdown(head, GRPC_ERROR_REF(why));
-    head = head->next;
+    head->Shutdown(GRPC_ERROR_REF(why));
+    head = head->next_;
   }
   GRPC_ERROR_UNREF(why);
 }
 
-static bool is_power_of_2(size_t n) { return (n & (n - 1)) == 0; }
-
-void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
-                                grpc_handshaker* handshaker) {
+void HandshakeManager::Add(RefCountedPtr<Handshaker> handshaker) {
   if (grpc_handshaker_trace.enabled()) {
     gpr_log(
         GPR_INFO,
         "handshake_manager %p: adding handshaker %s [%p] at index %" PRIuPTR,
-        mgr, grpc_handshaker_name(handshaker), handshaker, mgr->count);
-  }
-  gpr_mu_lock(&mgr->mu);
-  // To avoid allocating memory for each handshaker we add, we double
-  // the number of elements every time we need more.
-  size_t realloc_count = 0;
-  if (mgr->count == 0) {
-    realloc_count = 2;
-  } else if (mgr->count >= 2 && is_power_of_2(mgr->count)) {
-    realloc_count = mgr->count * 2;
-  }
-  if (realloc_count > 0) {
-    mgr->handshakers = static_cast<grpc_handshaker**>(gpr_realloc(
-        mgr->handshakers, realloc_count * sizeof(grpc_handshaker*)));
+        this, handshaker->name(), handshaker.get(), handshakers_.size());
   }
-  mgr->handshakers[mgr->count++] = handshaker;
-  gpr_mu_unlock(&mgr->mu);
+  MutexLock lock(&mu_);
+  handshakers_.push_back(std::move(handshaker));
 }
 
-static void grpc_handshake_manager_unref(grpc_handshake_manager* mgr) {
-  if (gpr_unref(&mgr->refs)) {
-    for (size_t i = 0; i < mgr->count; ++i) {
-      grpc_handshaker_destroy(mgr->handshakers[i]);
-    }
-    gpr_free(mgr->handshakers);
-    gpr_mu_destroy(&mgr->mu);
-    gpr_free(mgr);
-  }
-}
-
-void grpc_handshake_manager_destroy(grpc_handshake_manager* mgr) {
-  grpc_handshake_manager_unref(mgr);
+HandshakeManager::~HandshakeManager() {
+  handshakers_.clear();
+  gpr_mu_destroy(&mu_);
 }
 
-void grpc_handshake_manager_shutdown(grpc_handshake_manager* mgr,
-                                     grpc_error* why) {
-  gpr_mu_lock(&mgr->mu);
-  // Shutdown the handshaker that's currently in progress, if any.
-  if (!mgr->shutdown && mgr->index > 0) {
-    mgr->shutdown = true;
-    grpc_handshaker_shutdown(mgr->handshakers[mgr->index - 1],
-                             GRPC_ERROR_REF(why));
+void HandshakeManager::Shutdown(grpc_error* why) {
+  {
+    MutexLock lock(&mu_);
+    // Shutdown the handshaker that's currently in progress, if any.
+    if (!is_shutdown_ && index_ > 0) {
+      is_shutdown_ = true;
+      handshakers_[index_ - 1]->Shutdown(GRPC_ERROR_REF(why));
+    }
   }
-  gpr_mu_unlock(&mgr->mu);
   GRPC_ERROR_UNREF(why);
 }
 
-static char* handshaker_args_string(grpc_handshaker_args* args) {
-  char* args_str = grpc_channel_args_string(args->args);
-  size_t num_args = args->args != nullptr ? args->args->num_args : 0;
-  size_t read_buffer_length =
-      args->read_buffer != nullptr ? args->read_buffer->length : 0;
-  char* str;
-  gpr_asprintf(&str,
-               "{endpoint=%p, args=%p {size=%" PRIuPTR
-               ": %s}, read_buffer=%p (length=%" PRIuPTR "), exit_early=%d}",
-               args->endpoint, args->args, num_args, args_str,
-               args->read_buffer, read_buffer_length, args->exit_early);
-  gpr_free(args_str);
-  return str;
-}
-
 // Helper function to call either the next handshaker or the
 // on_handshake_done callback.
 // Returns true if we've scheduled the on_handshake_done callback.
-static bool call_next_handshaker_locked(grpc_handshake_manager* mgr,
-                                        grpc_error* error) {
+bool HandshakeManager::CallNextHandshakerLocked(grpc_error* error) {
   if (grpc_handshaker_trace.enabled()) {
-    char* args_str = handshaker_args_string(&mgr->args);
+    char* args_str = HandshakerArgsString(&args_);
     gpr_log(GPR_INFO,
             "handshake_manager %p: error=%s shutdown=%d index=%" PRIuPTR
             ", args=%s",
-            mgr, grpc_error_string(error), mgr->shutdown, mgr->index, args_str);
+            this, grpc_error_string(error), is_shutdown_, index_, args_str);
     gpr_free(args_str);
   }
-  GPR_ASSERT(mgr->index <= mgr->count);
+  GPR_ASSERT(index_ <= handshakers_.size());
   // If we got an error or we've been shut down or we're exiting early or
   // we've finished the last handshaker, invoke the on_handshake_done
   // callback.  Otherwise, call the next handshaker.
-  if (error != GRPC_ERROR_NONE || mgr->shutdown || mgr->args.exit_early ||
-      mgr->index == mgr->count) {
-    if (error == GRPC_ERROR_NONE && mgr->shutdown) {
+  if (error != GRPC_ERROR_NONE || is_shutdown_ || args_.exit_early ||
+      index_ == handshakers_.size()) {
+    if (error == GRPC_ERROR_NONE && is_shutdown_) {
       error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("handshaker shutdown");
       // It is possible that the endpoint has already been destroyed by
       // a shutdown call while this callback was sitting on the ExecCtx
       // with no error.
-      if (mgr->args.endpoint != nullptr) {
+      if (args_.endpoint != nullptr) {
         // TODO(roth): It is currently necessary to shutdown endpoints
         // before destroying then, even when we know that there are no
         // pending read/write callbacks.  This should be fixed, at which
         // point this can be removed.
-        grpc_endpoint_shutdown(mgr->args.endpoint, GRPC_ERROR_REF(error));
-        grpc_endpoint_destroy(mgr->args.endpoint);
-        mgr->args.endpoint = nullptr;
-        grpc_channel_args_destroy(mgr->args.args);
-        mgr->args.args = nullptr;
-        grpc_slice_buffer_destroy_internal(mgr->args.read_buffer);
-        gpr_free(mgr->args.read_buffer);
-        mgr->args.read_buffer = nullptr;
+        grpc_endpoint_shutdown(args_.endpoint, GRPC_ERROR_REF(error));
+        grpc_endpoint_destroy(args_.endpoint);
+        args_.endpoint = nullptr;
+        grpc_channel_args_destroy(args_.args);
+        args_.args = nullptr;
+        grpc_slice_buffer_destroy_internal(args_.read_buffer);
+        gpr_free(args_.read_buffer);
+        args_.read_buffer = nullptr;
       }
     }
     if (grpc_handshaker_trace.enabled()) {
       gpr_log(GPR_INFO,
               "handshake_manager %p: handshaking complete -- scheduling "
               "on_handshake_done with error=%s",
-              mgr, grpc_error_string(error));
+              this, grpc_error_string(error));
     }
     // Cancel deadline timer, since we're invoking the on_handshake_done
     // callback now.
-    grpc_timer_cancel(&mgr->deadline_timer);
-    GRPC_CLOSURE_SCHED(&mgr->on_handshake_done, error);
-    mgr->shutdown = true;
+    grpc_timer_cancel(&deadline_timer_);
+    GRPC_CLOSURE_SCHED(&on_handshake_done_, error);
+    is_shutdown_ = true;
   } else {
+    auto handshaker = handshakers_[index_];
     if (grpc_handshaker_trace.enabled()) {
       gpr_log(
           GPR_INFO,
           "handshake_manager %p: calling handshaker %s [%p] at index %" PRIuPTR,
-          mgr, grpc_handshaker_name(mgr->handshakers[mgr->index]),
-          mgr->handshakers[mgr->index], mgr->index);
+          this, handshaker->name(), handshaker.get(), index_);
     }
-    grpc_handshaker_do_handshake(mgr->handshakers[mgr->index], mgr->acceptor,
-                                 &mgr->call_next_handshaker, &mgr->args);
+    handshaker->DoHandshake(acceptor_, &call_next_handshaker_, &args_);
   }
-  ++mgr->index;
-  return mgr->shutdown;
+  ++index_;
+  return is_shutdown_;
 }
 
-// A function used as the handshaker-done callback when chaining
-// handshakers together.
-static void call_next_handshaker(void* arg, grpc_error* error) {
-  grpc_handshake_manager* mgr = static_cast<grpc_handshake_manager*>(arg);
-  gpr_mu_lock(&mgr->mu);
-  bool done = call_next_handshaker_locked(mgr, GRPC_ERROR_REF(error));
-  gpr_mu_unlock(&mgr->mu);
+void HandshakeManager::CallNextHandshakerFn(void* arg, grpc_error* error) {
+  auto* mgr = static_cast<HandshakeManager*>(arg);
+  bool done;
+  {
+    MutexLock lock(&mgr->mu_);
+    done = mgr->CallNextHandshakerLocked(GRPC_ERROR_REF(error));
+  }
   // If we're invoked the final callback, we won't be coming back
   // to this function, so we can release our reference to the
   // handshake manager.
   if (done) {
-    grpc_handshake_manager_unref(mgr);
+    mgr->Unref();
   }
 }
 
-// Callback invoked when deadline is exceeded.
-static void on_timeout(void* arg, grpc_error* error) {
-  grpc_handshake_manager* mgr = static_cast<grpc_handshake_manager*>(arg);
-  if (error == GRPC_ERROR_NONE) {  // Timer fired, rather than being cancelled.
-    grpc_handshake_manager_shutdown(
-        mgr, GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake timed out"));
+void HandshakeManager::OnTimeoutFn(void* arg, grpc_error* error) {
+  auto* mgr = static_cast<HandshakeManager*>(arg);
+  if (error == GRPC_ERROR_NONE) {  // Timer fired, rather than being cancelled
+    mgr->Shutdown(GRPC_ERROR_CREATE_FROM_STATIC_STRING("Handshake timed out"));
   }
-  grpc_handshake_manager_unref(mgr);
+  mgr->Unref();
 }
 
-void grpc_handshake_manager_do_handshake(grpc_handshake_manager* mgr,
-                                         grpc_endpoint* endpoint,
-                                         const grpc_channel_args* channel_args,
-                                         grpc_millis deadline,
-                                         grpc_tcp_server_acceptor* acceptor,
-                                         grpc_iomgr_cb_func on_handshake_done,
-                                         void* user_data) {
-  gpr_mu_lock(&mgr->mu);
-  GPR_ASSERT(mgr->index == 0);
-  GPR_ASSERT(!mgr->shutdown);
-  // Construct handshaker args.  These will be passed through all
-  // handshakers and eventually be freed by the on_handshake_done callback.
-  mgr->args.endpoint = endpoint;
-  mgr->args.args = grpc_channel_args_copy(channel_args);
-  mgr->args.user_data = user_data;
-  mgr->args.read_buffer = static_cast<grpc_slice_buffer*>(
-      gpr_malloc(sizeof(*mgr->args.read_buffer)));
-  grpc_slice_buffer_init(mgr->args.read_buffer);
-  // Initialize state needed for calling handshakers.
-  mgr->acceptor = acceptor;
-  GRPC_CLOSURE_INIT(&mgr->call_next_handshaker, call_next_handshaker, mgr,
-                    grpc_schedule_on_exec_ctx);
-  GRPC_CLOSURE_INIT(&mgr->on_handshake_done, on_handshake_done, &mgr->args,
-                    grpc_schedule_on_exec_ctx);
-  // Start deadline timer, which owns a ref.
-  gpr_ref(&mgr->refs);
-  GRPC_CLOSURE_INIT(&mgr->on_timeout, on_timeout, mgr,
-                    grpc_schedule_on_exec_ctx);
-  grpc_timer_init(&mgr->deadline_timer, deadline, &mgr->on_timeout);
-  // Start first handshaker, which also owns a ref.
-  gpr_ref(&mgr->refs);
-  bool done = call_next_handshaker_locked(mgr, GRPC_ERROR_NONE);
-  gpr_mu_unlock(&mgr->mu);
+void HandshakeManager::DoHandshake(grpc_endpoint* endpoint,
+                                   const grpc_channel_args* channel_args,
+                                   grpc_millis deadline,
+                                   grpc_tcp_server_acceptor* acceptor,
+                                   grpc_iomgr_cb_func on_handshake_done,
+                                   void* user_data) {
+  bool done;
+  {
+    MutexLock lock(&mu_);
+    GPR_ASSERT(index_ == 0);
+    GPR_ASSERT(!is_shutdown_);
+    // Construct handshaker args.  These will be passed through all
+    // handshakers and eventually be freed by the on_handshake_done callback.
+    args_.endpoint = endpoint;
+    args_.args = grpc_channel_args_copy(channel_args);
+    args_.user_data = user_data;
+    args_.read_buffer =
+        static_cast<grpc_slice_buffer*>(gpr_malloc(sizeof(*args_.read_buffer)));
+    grpc_slice_buffer_init(args_.read_buffer);
+    // Initialize state needed for calling handshakers.
+    acceptor_ = acceptor;
+    GRPC_CLOSURE_INIT(&call_next_handshaker_,
+                      &HandshakeManager::CallNextHandshakerFn, this,
+                      grpc_schedule_on_exec_ctx);
+    GRPC_CLOSURE_INIT(&on_handshake_done_, on_handshake_done, &args_,
+                      grpc_schedule_on_exec_ctx);
+    // Start deadline timer, which owns a ref.
+    Ref().release();
+    GRPC_CLOSURE_INIT(&on_timeout_, &HandshakeManager::OnTimeoutFn, this,
+                      grpc_schedule_on_exec_ctx);
+    grpc_timer_init(&deadline_timer_, deadline, &on_timeout_);
+    // Start first handshaker, which also owns a ref.
+    Ref().release();
+    done = CallNextHandshakerLocked(GRPC_ERROR_NONE);
+  }
   if (done) {
-    grpc_handshake_manager_unref(mgr);
+    Unref();
   }
 }
+
+}  // namespace grpc_core
+
+void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
+                                grpc_handshaker* handshaker) {
+  // This is a transition method to aid the API change for handshakers.
+  using namespace grpc_core;
+  RefCountedPtr<Handshaker> refd_hs(static_cast<Handshaker*>(handshaker));
+  mgr->Add(refd_hs);
+}