grpc 1.18.0 → 1.19.0.pre1

data/src/core/ext/filters/client_channel/subchannel_pool_interface.h

@@ -0,0 +1,94 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/avl/avl.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/abstract.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+
+namespace grpc_core {
+
+class Subchannel;
+
+extern TraceFlag grpc_subchannel_pool_trace;
+
+// A key that can uniquely identify a subchannel.
+class SubchannelKey {
+ public:
+  explicit SubchannelKey(const grpc_channel_args* args);
+  ~SubchannelKey();
+
+  // Copyable.
+  SubchannelKey(const SubchannelKey& other);
+  SubchannelKey& operator=(const SubchannelKey& other);
+  // Not movable.
+  SubchannelKey(SubchannelKey&&) = delete;
+  SubchannelKey& operator=(SubchannelKey&&) = delete;
+
+  int Cmp(const SubchannelKey& other) const;
+
+ private:
+  // Initializes the subchannel key with the given \a args and the function to
+  // copy channel args.
+  void Init(
+      const grpc_channel_args* args,
+      grpc_channel_args* (*copy_channel_args)(const grpc_channel_args* args));
+
+  const grpc_channel_args* args_;
+};
+
+// Interface for subchannel pool.
+// TODO(juanlishen): This refcounting mechanism may lead to memory leak.
+// To solve that, we should force polling to flush any pending callbacks, then
+// shut down safely. See https://github.com/grpc/grpc/issues/12560.
+class SubchannelPoolInterface : public RefCounted<SubchannelPoolInterface> {
+ public:
+  SubchannelPoolInterface() : RefCounted(&grpc_subchannel_pool_trace) {}
+  virtual ~SubchannelPoolInterface() {}
+
+  // Registers a subchannel against a key. Returns the subchannel registered
+  // with \a key, which may be different from \a constructed because we reuse
+  // (instead of update) any existing subchannel already registered with \a key.
+  virtual Subchannel* RegisterSubchannel(SubchannelKey* key,
+                                         Subchannel* constructed) GRPC_ABSTRACT;
+
+  // Removes the registered subchannel found by \a key.
+  virtual void UnregisterSubchannel(SubchannelKey* key) GRPC_ABSTRACT;
+
+  // Finds the subchannel registered for the given subchannel key. Returns NULL
+  // if no such channel exists. Thread-safe.
+  virtual Subchannel* FindSubchannel(SubchannelKey* key) GRPC_ABSTRACT;
+
+  // Creates a channel arg from \a subchannel pool.
+  static grpc_arg CreateChannelArg(SubchannelPoolInterface* subchannel_pool);
+
+  // Gets the subchannel pool from the channel args.
+  static SubchannelPoolInterface* GetSubchannelPoolFromChannelArgs(
+      const grpc_channel_args* args);
+
+  GRPC_ABSTRACT_BASE_CLASS
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H */

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -45,6 +45,7 @@ struct call_data {
 
 struct channel_data {
   grpc_slice default_authority;
+  grpc_mdelem default_authority_mdelem;
 };
 
 void authority_start_transport_stream_op_batch(
@@ -59,8 +60,7 @@ void authority_start_transport_stream_op_batch(
       initial_metadata->idx.named.authority == nullptr) {
     grpc_error* error = grpc_metadata_batch_add_head(
         initial_metadata, &calld->authority_storage,
-        grpc_mdelem_create(GRPC_MDSTR_AUTHORITY, chand->default_authority,
-                           nullptr));
+        GRPC_MDELEM_REF(chand->default_authority_mdelem));
     if (error != GRPC_ERROR_NONE) {
       grpc_transport_stream_op_batch_finish_with_failure(batch, error,
                                                          calld->call_combiner);
@@ -103,6 +103,8 @@ grpc_error* init_channel_elem(grpc_channel_element* elem,
   }
   chand->default_authority =
       grpc_slice_intern(grpc_slice_from_static_string(default_authority_str));
+  chand->default_authority_mdelem = grpc_mdelem_create(
+      GRPC_MDSTR_AUTHORITY, chand->default_authority, nullptr);
   GPR_ASSERT(!args->is_last);
   return GRPC_ERROR_NONE;
 }
@@ -111,6 +113,7 @@ grpc_error* init_channel_elem(grpc_channel_element* elem,
 void destroy_channel_elem(grpc_channel_element* elem) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   grpc_slice_unref_internal(chand->default_authority);
+  GRPC_MDELEM_UNREF(chand->default_authority_mdelem);
 }
 }  // namespace
 

data/src/core/ext/filters/max_age/max_age_filter.cc

@@ -106,7 +106,7 @@ struct channel_data {
      +--------------------------------+----------------+---------+
 
      MAX_IDLE_STATE_INIT: The initial and final state of 'idle_state'. The
-     channel has 1 or 1+ active calls, and the the timer is not set. Note that
+     channel has 1 or 1+ active calls, and the timer is not set. Note that
      we may put a virtual call to hold this state at channel initialization or
      shutdown, so that the channel won't enter other states.
 

data/src/core/ext/transport/chttp2/client/chttp2_connector.cc

@@ -55,7 +55,7 @@ typedef struct {
 
   grpc_closure connected;
 
-  grpc_handshake_manager* handshake_mgr;
+  grpc_core::RefCountedPtr<grpc_core::HandshakeManager> handshake_mgr;
 } chttp2_connector;
 
 static void chttp2_connector_ref(grpc_connector* con) {
@@ -79,7 +79,7 @@ static void chttp2_connector_shutdown(grpc_connector* con, grpc_error* why) {
   gpr_mu_lock(&c->mu);
   c->shutdown = true;
   if (c->handshake_mgr != nullptr) {
-    grpc_handshake_manager_shutdown(c->handshake_mgr, GRPC_ERROR_REF(why));
+    c->handshake_mgr->Shutdown(GRPC_ERROR_REF(why));
   }
   // If handshaking is not yet in progress, shutdown the endpoint.
   // Otherwise, the handshaker will do this for us.
@@ -91,7 +91,7 @@ static void chttp2_connector_shutdown(grpc_connector* con, grpc_error* why) {
 }
 
 static void on_handshake_done(void* arg, grpc_error* error) {
-  grpc_handshaker_args* args = static_cast<grpc_handshaker_args*>(arg);
+  auto* args = static_cast<grpc_core::HandshakerArgs*>(arg);
   chttp2_connector* c = static_cast<chttp2_connector*>(args->user_data);
   gpr_mu_lock(&c->mu);
   if (error != GRPC_ERROR_NONE || c->shutdown) {
@@ -152,20 +152,20 @@ static void on_handshake_done(void* arg, grpc_error* error) {
   grpc_closure* notify = c->notify;
   c->notify = nullptr;
   GRPC_CLOSURE_SCHED(notify, error);
-  grpc_handshake_manager_destroy(c->handshake_mgr);
-  c->handshake_mgr = nullptr;
+  c->handshake_mgr.reset();
   gpr_mu_unlock(&c->mu);
   chttp2_connector_unref(reinterpret_cast<grpc_connector*>(c));
 }
 
 static void start_handshake_locked(chttp2_connector* c) {
-  c->handshake_mgr = grpc_handshake_manager_create();
-  grpc_handshakers_add(HANDSHAKER_CLIENT, c->args.channel_args,
-                       c->args.interested_parties, c->handshake_mgr);
+  c->handshake_mgr = grpc_core::MakeRefCounted<grpc_core::HandshakeManager>();
+  grpc_core::HandshakerRegistry::AddHandshakers(
+      grpc_core::HANDSHAKER_CLIENT, c->args.channel_args,
+      c->args.interested_parties, c->handshake_mgr.get());
   grpc_endpoint_add_to_pollset_set(c->endpoint, c->args.interested_parties);
-  grpc_handshake_manager_do_handshake(
-      c->handshake_mgr, c->endpoint, c->args.channel_args, c->args.deadline,
-      nullptr /* acceptor */, on_handshake_done, c);
+  c->handshake_mgr->DoHandshake(c->endpoint, c->args.channel_args,
+                                c->args.deadline, nullptr /* acceptor */,
+                                on_handshake_done, c);
   c->endpoint = nullptr;  // Endpoint handed off to handshake manager.
 }
 
@@ -202,7 +202,8 @@ static void chttp2_connector_connect(grpc_connector* con,
                                      grpc_closure* notify) {
   chttp2_connector* c = reinterpret_cast<chttp2_connector*>(con);
   grpc_resolved_address addr;
-  grpc_get_subchannel_address_arg(args->channel_args, &addr);
+  grpc_core::Subchannel::GetAddressFromSubchannelAddressArg(args->channel_args,
+                                                            &addr);
   gpr_mu_lock(&c->mu);
   GPR_ASSERT(c->notify == nullptr);
   c->notify = notify;

data/src/core/ext/transport/chttp2/client/insecure/channel_create.cc

@@ -39,15 +39,13 @@ static void client_channel_factory_ref(
 static void client_channel_factory_unref(
     grpc_client_channel_factory* cc_factory) {}
 
-static grpc_subchannel* client_channel_factory_create_subchannel(
-    grpc_client_channel_factory* cc_factory, const grpc_subchannel_args* args) {
-  grpc_subchannel_args final_sc_args;
-  memcpy(&final_sc_args, args, sizeof(*args));
-  final_sc_args.args = grpc_default_authority_add_if_not_present(args->args);
+static grpc_core::Subchannel* client_channel_factory_create_subchannel(
+    grpc_client_channel_factory* cc_factory, const grpc_channel_args* args) {
+  grpc_channel_args* new_args = grpc_default_authority_add_if_not_present(args);
   grpc_connector* connector = grpc_chttp2_connector_create();
-  grpc_subchannel* s = grpc_subchannel_create(connector, &final_sc_args);
+  grpc_core::Subchannel* s = grpc_core::Subchannel::Create(connector, new_args);
   grpc_connector_unref(connector);
-  grpc_channel_args_destroy(const_cast<grpc_channel_args*>(final_sc_args.args));
+  grpc_channel_args_destroy(new_args);
   return s;
 }
 

data/src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc

@@ -46,10 +46,10 @@ static void client_channel_factory_ref(
 static void client_channel_factory_unref(
     grpc_client_channel_factory* cc_factory) {}
 
-static grpc_subchannel_args* get_secure_naming_subchannel_args(
-    const grpc_subchannel_args* args) {
+static grpc_channel_args* get_secure_naming_channel_args(
+    const grpc_channel_args* args) {
   grpc_channel_credentials* channel_credentials =
-      grpc_channel_credentials_find_in_args(args->args);
+      grpc_channel_credentials_find_in_args(args);
   if (channel_credentials == nullptr) {
     gpr_log(GPR_ERROR,
             "Can't create subchannel: channel credentials missing for secure "
@@ -57,7 +57,7 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
     return nullptr;
   }
   // Make sure security connector does not already exist in args.
-  if (grpc_security_connector_find_in_args(args->args) != nullptr) {
+  if (grpc_security_connector_find_in_args(args) != nullptr) {
     gpr_log(GPR_ERROR,
             "Can't create subchannel: security connector already present in "
             "channel args.");
@@ -65,19 +65,19 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
   }
   // To which address are we connecting? By default, use the server URI.
   const grpc_arg* server_uri_arg =
-      grpc_channel_args_find(args->args, GRPC_ARG_SERVER_URI);
+      grpc_channel_args_find(args, GRPC_ARG_SERVER_URI);
   const char* server_uri_str = grpc_channel_arg_get_string(server_uri_arg);
   GPR_ASSERT(server_uri_str != nullptr);
   grpc_uri* server_uri =
       grpc_uri_parse(server_uri_str, true /* supress errors */);
   GPR_ASSERT(server_uri != nullptr);
   const grpc_core::TargetAuthorityTable* target_authority_table =
-      grpc_core::FindTargetAuthorityTableInArgs(args->args);
+      grpc_core::FindTargetAuthorityTableInArgs(args);
   grpc_core::UniquePtr<char> authority;
   if (target_authority_table != nullptr) {
     // Find the authority for the target.
     const char* target_uri_str =
-        grpc_get_subchannel_address_uri_arg(args->args);
+        grpc_core::Subchannel::GetUriFromSubchannelAddressArg(args);
     grpc_uri* target_uri =
         grpc_uri_parse(target_uri_str, false /* suppress errors */);
     GPR_ASSERT(target_uri != nullptr);
@@ -100,15 +100,14 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
   }
   grpc_arg args_to_add[2];
   size_t num_args_to_add = 0;
-  if (grpc_channel_args_find(args->args, GRPC_ARG_DEFAULT_AUTHORITY) ==
-      nullptr) {
+  if (grpc_channel_args_find(args, GRPC_ARG_DEFAULT_AUTHORITY) == nullptr) {
     // If the channel args don't already contain GRPC_ARG_DEFAULT_AUTHORITY, add
     // the arg, setting it to the value just obtained.
     args_to_add[num_args_to_add++] = grpc_channel_arg_string_create(
         const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY), authority.get());
   }
   grpc_channel_args* args_with_authority =
-      grpc_channel_args_copy_and_add(args->args, args_to_add, num_args_to_add);
+      grpc_channel_args_copy_and_add(args, args_to_add, num_args_to_add);
   grpc_uri_destroy(server_uri);
   // Create the security connector using the credentials and target name.
   grpc_channel_args* new_args_from_connector = nullptr;
@@ -137,29 +136,21 @@ static grpc_subchannel_args* get_secure_naming_subchannel_args(
     grpc_channel_args_destroy(new_args_from_connector);
   }
   grpc_channel_args_destroy(args_with_authority);
-  grpc_subchannel_args* final_sc_args =
-      static_cast<grpc_subchannel_args*>(gpr_malloc(sizeof(*final_sc_args)));
-  memcpy(final_sc_args, args, sizeof(*args));
-  final_sc_args->args = new_args;
-  return final_sc_args;
+  return new_args;
 }
 
-static grpc_subchannel* client_channel_factory_create_subchannel(
-    grpc_client_channel_factory* cc_factory, const grpc_subchannel_args* args) {
-  grpc_subchannel_args* subchannel_args =
-      get_secure_naming_subchannel_args(args);
-  if (subchannel_args == nullptr) {
-    gpr_log(
-        GPR_ERROR,
-        "Failed to create subchannel arguments during subchannel creation.");
+static grpc_core::Subchannel* client_channel_factory_create_subchannel(
+    grpc_client_channel_factory* cc_factory, const grpc_channel_args* args) {
+  grpc_channel_args* new_args = get_secure_naming_channel_args(args);
+  if (new_args == nullptr) {
+    gpr_log(GPR_ERROR,
+            "Failed to create channel args during subchannel creation.");
     return nullptr;
   }
   grpc_connector* connector = grpc_chttp2_connector_create();
-  grpc_subchannel* s = grpc_subchannel_create(connector, subchannel_args);
+  grpc_core::Subchannel* s = grpc_core::Subchannel::Create(connector, new_args);
   grpc_connector_unref(connector);
-  grpc_channel_args_destroy(
-      const_cast<grpc_channel_args*>(subchannel_args->args));
-  gpr_free(subchannel_args);
+  grpc_channel_args_destroy(new_args);
   return s;
 }
 
@@ -215,6 +206,7 @@ grpc_channel* grpc_secure_channel_create(grpc_channel_credentials* creds,
         grpc_channel_credentials_to_arg(creds)};
     grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
         args, args_to_add, GPR_ARRAY_SIZE(args_to_add));
+    new_args = creds->update_arguments(new_args);
     // Create channel.
     channel = client_channel_factory_create_channel(
         &client_channel_factory, target, GRPC_CLIENT_CHANNEL_TYPE_REGULAR,

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -54,7 +54,7 @@ typedef struct {
   bool shutdown;
   grpc_closure tcp_server_shutdown_complete;
   grpc_closure* server_destroy_listener_done;
-  grpc_handshake_manager* pending_handshake_mgrs;
+  grpc_core::HandshakeManager* pending_handshake_mgrs;
   grpc_core::RefCountedPtr<grpc_core::channelz::ListenSocketNode>
       channelz_listen_socket;
 } server_state;
@@ -64,7 +64,7 @@ typedef struct {
   server_state* svr_state;
   grpc_pollset* accepting_pollset;
   grpc_tcp_server_acceptor* acceptor;
-  grpc_handshake_manager* handshake_mgr;
+  grpc_core::RefCountedPtr<grpc_core::HandshakeManager> handshake_mgr;
   // State for enforcing handshake timeout on receiving HTTP/2 settings.
   grpc_chttp2_transport* transport;
   grpc_millis deadline;
@@ -112,7 +112,7 @@ static void on_receive_settings(void* arg, grpc_error* error) {
 }
 
 static void on_handshake_done(void* arg, grpc_error* error) {
-  grpc_handshaker_args* args = static_cast<grpc_handshaker_args*>(arg);
+  auto* args = static_cast<grpc_core::HandshakerArgs*>(arg);
   server_connection_state* connection_state =
       static_cast<server_connection_state*>(args->user_data);
   gpr_mu_lock(&connection_state->svr_state->mu);
@@ -175,11 +175,10 @@ static void on_handshake_done(void* arg, grpc_error* error) {
       }
     }
   }
-  grpc_handshake_manager_pending_list_remove(
-      &connection_state->svr_state->pending_handshake_mgrs,
-      connection_state->handshake_mgr);
+  connection_state->handshake_mgr->RemoveFromPendingMgrList(
+      &connection_state->svr_state->pending_handshake_mgrs);
   gpr_mu_unlock(&connection_state->svr_state->mu);
-  grpc_handshake_manager_destroy(connection_state->handshake_mgr);
+  connection_state->handshake_mgr.reset();
   gpr_free(connection_state->acceptor);
   grpc_tcp_server_unref(connection_state->svr_state->tcp_server);
   server_connection_state_unref(connection_state);
@@ -211,9 +210,8 @@ static void on_accept(void* arg, grpc_endpoint* tcp,
     gpr_free(acceptor);
     return;
   }
-  grpc_handshake_manager* handshake_mgr = grpc_handshake_manager_create();
-  grpc_handshake_manager_pending_list_add(&state->pending_handshake_mgrs,
-                                          handshake_mgr);
+  auto handshake_mgr = grpc_core::MakeRefCounted<grpc_core::HandshakeManager>();
+  handshake_mgr->AddToPendingMgrList(&state->pending_handshake_mgrs);
   grpc_tcp_server_ref(state->tcp_server);
   gpr_mu_unlock(&state->mu);
   server_connection_state* connection_state =
@@ -227,19 +225,19 @@ static void on_accept(void* arg, grpc_endpoint* tcp,
   connection_state->interested_parties = grpc_pollset_set_create();
   grpc_pollset_set_add_pollset(connection_state->interested_parties,
                                connection_state->accepting_pollset);
-  grpc_handshakers_add(HANDSHAKER_SERVER, state->args,
-                       connection_state->interested_parties,
-                       connection_state->handshake_mgr);
+  grpc_core::HandshakerRegistry::AddHandshakers(
+      grpc_core::HANDSHAKER_SERVER, state->args,
+      connection_state->interested_parties,
+      connection_state->handshake_mgr.get());
   const grpc_arg* timeout_arg =
       grpc_channel_args_find(state->args, GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS);
   connection_state->deadline =
       grpc_core::ExecCtx::Get()->Now() +
       grpc_channel_arg_get_integer(timeout_arg,
                                    {120 * GPR_MS_PER_SEC, 1, INT_MAX});
-  grpc_handshake_manager_do_handshake(connection_state->handshake_mgr, tcp,
-                                      state->args, connection_state->deadline,
-                                      acceptor, on_handshake_done,
-                                      connection_state);
+  connection_state->handshake_mgr->DoHandshake(
+      tcp, state->args, connection_state->deadline, acceptor, on_handshake_done,
+      connection_state);
 }
 
 /* Server callback: start listening on our ports */
@@ -260,8 +258,9 @@ static void tcp_server_shutdown_complete(void* arg, grpc_error* error) {
   gpr_mu_lock(&state->mu);
   grpc_closure* destroy_done = state->server_destroy_listener_done;
   GPR_ASSERT(state->shutdown);
-  grpc_handshake_manager_pending_list_shutdown_all(
-      state->pending_handshake_mgrs, GRPC_ERROR_REF(error));
+  if (state->pending_handshake_mgrs != nullptr) {
+    state->pending_handshake_mgrs->ShutdownAllPending(GRPC_ERROR_REF(error));
+  }
   state->channelz_listen_socket.reset();
   gpr_mu_unlock(&state->mu);
   // Flush queued work before destroying handshaker factory, since that

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

@@ -43,6 +43,7 @@
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/executor.h"
+#include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -963,24 +964,28 @@ void grpc_chttp2_mark_stream_writable(grpc_chttp2_transport* t,
 static grpc_closure_scheduler* write_scheduler(grpc_chttp2_transport* t,
                                                bool early_results_scheduled,
                                                bool partial_write) {
+  // If we're already in a background poller, don't offload this to an executor
+  if (grpc_iomgr_is_any_background_poller_thread()) {
+    return grpc_schedule_on_exec_ctx;
+  }
   /* if it's not the first write in a batch, always offload to the executor:
      we'll probably end up queuing against the kernel anyway, so we'll likely
      get better latency overall if we switch writing work elsewhere and continue
      with application work above */
   if (!t->is_first_write_in_batch) {
-    return grpc_executor_scheduler(GRPC_EXECUTOR_SHORT);
+    return grpc_core::Executor::Scheduler(grpc_core::ExecutorJobType::SHORT);
   }
   /* equivalently, if it's a partial write, we *know* we're going to be taking a
      thread jump to write it because of the above, may as well do so
      immediately */
   if (partial_write) {
-    return grpc_executor_scheduler(GRPC_EXECUTOR_SHORT);
+    return grpc_core::Executor::Scheduler(grpc_core::ExecutorJobType::SHORT);
   }
   switch (t->opt_target) {
     case GRPC_CHTTP2_OPTIMIZE_FOR_THROUGHPUT:
       /* executor gives us the largest probability of being able to batch a
        * write with others on this transport */
-      return grpc_executor_scheduler(GRPC_EXECUTOR_SHORT);
+      return grpc_core::Executor::Scheduler(grpc_core::ExecutorJobType::SHORT);
     case GRPC_CHTTP2_OPTIMIZE_FOR_LATENCY:
       return grpc_schedule_on_exec_ctx;
   }
@@ -1114,9 +1119,6 @@ static void queue_setting_update(grpc_chttp2_transport* t,
 void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
                                      uint32_t goaway_error,
                                      grpc_slice goaway_text) {
-  // GRPC_CHTTP2_IF_TRACING(
-  //     gpr_log(GPR_INFO, "got goaway [%d]: %s", goaway_error, msg));
-
   // Discard the error from a previous goaway frame (if any)
   if (t->goaway_error != GRPC_ERROR_NONE) {
     GRPC_ERROR_UNREF(t->goaway_error);
@@ -1127,6 +1129,10 @@ void grpc_chttp2_add_incoming_goaway(grpc_chttp2_transport* t,
           GRPC_ERROR_INT_HTTP2_ERROR, static_cast<intptr_t>(goaway_error)),
       GRPC_ERROR_STR_RAW_BYTES, goaway_text);
 
+  /* We want to log this irrespective of whether http tracing is enabled */
+  gpr_log(GPR_INFO, "%s: Got goaway [%d] err=%s", t->peer_string, goaway_error,
+          grpc_error_string(t->goaway_error));
+
   /* When a client receives a GOAWAY with error code ENHANCE_YOUR_CALM and debug
    * data equal to "too_many_pings", it should log the occurrence at a log level
    * that is enabled by default and double the configured KEEPALIVE_TIME used
@@ -1769,6 +1775,9 @@ void grpc_chttp2_ack_ping(grpc_chttp2_transport* t, uint64_t id) {
 }
 
 static void send_goaway(grpc_chttp2_transport* t, grpc_error* error) {
+  /* We want to log this irrespective of whether http tracing is enabled */
+  gpr_log(GPR_INFO, "%s: Sending goaway err=%s", t->peer_string,
+          grpc_error_string(error));
   t->sent_goaway_state = GRPC_CHTTP2_GOAWAY_SEND_SCHEDULED;
   grpc_http2_error_code http_error;
   grpc_slice slice;
@@ -2549,6 +2558,10 @@ static void read_action_locked(void* tp, grpc_error* error) {
   } else if (t->closed_with_error == GRPC_ERROR_NONE) {
     keep_reading = true;
     GRPC_CHTTP2_REF_TRANSPORT(t, "keep_reading");
+    /* Since we have read a byte, reset the keepalive timer */
+    if (t->keepalive_state == GRPC_CHTTP2_KEEPALIVE_STATE_WAITING) {
+      grpc_timer_cancel(&t->keepalive_ping_timer);
+    }
   }
   grpc_slice_buffer_reset_and_unref_internal(&t->read_buffer);
 
@@ -2718,6 +2731,9 @@ static void start_keepalive_ping_locked(void* arg, grpc_error* error) {
   if (t->channelz_socket != nullptr) {
     t->channelz_socket->RecordKeepaliveSent();
   }
+  if (grpc_http_trace.enabled()) {
+    gpr_log(GPR_INFO, "%s: Start keepalive ping", t->peer_string);
+  }
   GRPC_CHTTP2_REF_TRANSPORT(t, "keepalive watchdog");
   grpc_timer_init(&t->keepalive_watchdog_timer,
                   grpc_core::ExecCtx::Get()->Now() + t->keepalive_timeout,
@@ -2728,6 +2744,9 @@ static void finish_keepalive_ping_locked(void* arg, grpc_error* error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
   if (t->keepalive_state == GRPC_CHTTP2_KEEPALIVE_STATE_PINGING) {
     if (error == GRPC_ERROR_NONE) {
+      if (grpc_http_trace.enabled()) {
+        gpr_log(GPR_INFO, "%s: Finish keepalive ping", t->peer_string);
+      }
       t->keepalive_state = GRPC_CHTTP2_KEEPALIVE_STATE_WAITING;
       grpc_timer_cancel(&t->keepalive_watchdog_timer);
       GRPC_CHTTP2_REF_TRANSPORT(t, "init keepalive ping");
@@ -2743,6 +2762,8 @@ static void keepalive_watchdog_fired_locked(void* arg, grpc_error* error) {
   grpc_chttp2_transport* t = static_cast<grpc_chttp2_transport*>(arg);
   if (t->keepalive_state == GRPC_CHTTP2_KEEPALIVE_STATE_PINGING) {
     if (error == GRPC_ERROR_NONE) {
+      gpr_log(GPR_ERROR, "%s: Keepalive watchdog fired. Closing transport.",
+              t->peer_string);
       t->keepalive_state = GRPC_CHTTP2_KEEPALIVE_STATE_DYING;
       close_transport_locked(
           t, grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(