grpc 1.46.3-x86_64-linux → 1.47.0-x86_64-linux

data/src/core/ext/filters/client_channel/subchannel.cc

@@ -23,36 +23,43 @@
 
 #include <algorithm>
 #include <cstring>
+#include <memory>
+#include <new>
+#include <type_traits>
+#include <utility>
 
-#include "absl/strings/str_format.h"
+#include "absl/status/statusor.h"
 
+#include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/health/health_check_client.h"
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
-#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/channel_stack_builder_impl.h"
-#include "src/core/lib/channel/connected_channel.h"
+#include "src/core/lib/channel/channel_trace.h"
+#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/alloc.h"
 #include "src/core/lib/gprpp/debug_location.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/profiling/timers.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/uri/uri_parser.h"
 
 // Strong and weak refs.
 #define INTERNAL_REF_BITS 16
@@ -308,43 +315,33 @@ class Subchannel::ConnectedSubchannelStateWatcher
                                  const absl::Status& status) override {
     Subchannel* c = subchannel_.get();
     MutexLock lock(&c->mu_);
-    switch (new_state) {
-      case GRPC_CHANNEL_TRANSIENT_FAILURE:
-      case GRPC_CHANNEL_SHUTDOWN: {
-        if (!c->disconnected_ && c->connected_subchannel_ != nullptr) {
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel)) {
-            gpr_log(GPR_INFO,
-                    "subchannel %p %s: Connected subchannel %p has gone into "
-                    "%s. Attempting to reconnect.",
-                    c, c->key_.ToString().c_str(),
-                    c->connected_subchannel_.get(),
-                    ConnectivityStateName(new_state));
-          }
-          c->connected_subchannel_.reset();
-          if (c->channelz_node() != nullptr) {
-            c->channelz_node()->SetChildSocket(nullptr);
-          }
-          // We need to construct our own status if the underlying state was
-          // shutdown since the accompanying status will be StatusCode::OK
-          // otherwise.
-          c->SetConnectivityStateLocked(
-              GRPC_CHANNEL_TRANSIENT_FAILURE,
-              new_state == GRPC_CHANNEL_SHUTDOWN
-                  ? absl::Status(absl::StatusCode::kUnavailable,
-                                 "Subchannel has disconnected.")
-                  : status);
-          c->backoff_begun_ = false;
-          c->backoff_.Reset();
-        }
-        break;
+    // If we're either shutting down or have already seen this connection
+    // failure (i.e., c->connected_subchannel_ is null), do nothing.
+    //
+    // The transport reports TRANSIENT_FAILURE upon GOAWAY but SHUTDOWN
+    // upon connection close.  So if the server gracefully shuts down,
+    // we will see TRANSIENT_FAILURE followed by SHUTDOWN, but if not, we
+    // will see only SHUTDOWN.  Either way, we react to the first one we
+    // see, ignoring anything that happens after that.
+    if (c->connected_subchannel_ == nullptr) return;
+    if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE ||
+        new_state == GRPC_CHANNEL_SHUTDOWN) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel)) {
+        gpr_log(GPR_INFO,
+                "subchannel %p %s: Connected subchannel %p reports %s: %s", c,
+                c->key_.ToString().c_str(), c->connected_subchannel_.get(),
+                ConnectivityStateName(new_state), status.ToString().c_str());
       }
-      default: {
-        // In principle, this should never happen.  We should not get
-        // a callback for READY, because that was the state we started
-        // this watch from.  And a connected subchannel should never go
-        // from READY to CONNECTING or IDLE.
-        c->SetConnectivityStateLocked(new_state, status);
+      c->connected_subchannel_.reset();
+      if (c->channelz_node() != nullptr) {
+        c->channelz_node()->SetChildSocket(nullptr);
       }
+      // Even though we're reporting IDLE instead of TRANSIENT_FAILURE here,
+      // pass along the status from the transport, since it may have
+      // keepalive info attached to it that the channel needs.
+      // TODO(roth): Consider whether there's a cleaner way to do this.
+      c->SetConnectivityStateLocked(GRPC_CHANNEL_IDLE, status);
+      c->backoff_.Reset();
     }
   }
 
@@ -563,6 +560,25 @@ Subchannel::HealthWatcherMap::CheckConnectivityStateLocked(
 
 void Subchannel::HealthWatcherMap::ShutdownLocked() { map_.clear(); }
 
+//
+// Subchannel::ConnectivityStateWatcherInterface
+//
+
+void Subchannel::ConnectivityStateWatcherInterface::PushConnectivityStateChange(
+    ConnectivityStateChange state_change) {
+  MutexLock lock(&mu_);
+  connectivity_state_queue_.push_back(std::move(state_change));
+}
+
+Subchannel::ConnectivityStateWatcherInterface::ConnectivityStateChange
+Subchannel::ConnectivityStateWatcherInterface::PopConnectivityStateChange() {
+  MutexLock lock(&mu_);
+  GPR_ASSERT(!connectivity_state_queue_.empty());
+  ConnectivityStateChange state_change = connectivity_state_queue_.front();
+  connectivity_state_queue_.pop_front();
+  return state_change;
+}
+
 //
 // Subchannel
 //
@@ -622,21 +638,6 @@ BackOff::Options ParseArgsForBackoffValues(const grpc_channel_args* args,
 
 }  // namespace
 
-void Subchannel::ConnectivityStateWatcherInterface::PushConnectivityStateChange(
-    ConnectivityStateChange state_change) {
-  MutexLock lock(&mu_);
-  connectivity_state_queue_.push_back(std::move(state_change));
-}
-
-Subchannel::ConnectivityStateWatcherInterface::ConnectivityStateChange
-Subchannel::ConnectivityStateWatcherInterface::PopConnectivityStateChange() {
-  MutexLock lock(&mu_);
-  GPR_ASSERT(!connectivity_state_queue_.empty());
-  ConnectivityStateChange state_change = connectivity_state_queue_.front();
-  connectivity_state_queue_.pop_front();
-  return state_change;
-}
-
 Subchannel::Subchannel(SubchannelKey key,
                        OrphanablePtr<SubchannelConnector> connector,
                        const grpc_channel_args* args)
@@ -650,6 +651,7 @@ Subchannel::Subchannel(SubchannelKey key,
   GRPC_STATS_INC_CLIENT_SUBCHANNELS_CREATED();
   GRPC_CLOSURE_INIT(&on_connecting_finished_, OnConnectingFinished, this,
                     grpc_schedule_on_exec_ctx);
+  GRPC_CLOSURE_INIT(&on_retry_timer_, OnRetryTimer, this, nullptr);
   // Check proxy mapper to determine address to connect to and channel
   // args to use.
   address_for_connect_ = key_.address();
@@ -676,7 +678,9 @@ Subchannel::Subchannel(SubchannelKey key,
             {GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT, 0,
              INT_MAX}));
     channelz_node_ = MakeRefCounted<channelz::SubchannelNode>(
-        grpc_sockaddr_to_uri(&key_.address()), channel_tracer_max_memory);
+        grpc_sockaddr_to_uri(&key_.address())
+            .value_or("<unknown address type>"),
+        channel_tracer_max_memory);
     channelz_node_->AddTraceEvent(
         channelz::ChannelTrace::Severity::Info,
         grpc_slice_from_static_string("subchannel created"));
@@ -787,20 +791,20 @@ void Subchannel::CancelConnectivityStateWatch(
   }
 }
 
-void Subchannel::AttemptToConnect() {
+void Subchannel::RequestConnection() {
   MutexLock lock(&mu_);
-  MaybeStartConnectingLocked();
+  if (state_ == GRPC_CHANNEL_IDLE) {
+    StartConnectingLocked();
+  } else if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE) {
+    connection_requested_ = true;
+  }
 }
 
 void Subchannel::ResetBackoff() {
   MutexLock lock(&mu_);
   backoff_.Reset();
-  if (have_retry_alarm_) {
-    retry_immediately_ = true;
-    grpc_timer_cancel(&retry_alarm_);
-  } else {
-    backoff_begun_ = false;
-    MaybeStartConnectingLocked();
+  if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE) {
+    grpc_timer_cancel(&retry_timer_);
   }
 }
 
@@ -812,13 +816,36 @@ void Subchannel::Orphan() {
     subchannel_pool_.reset();
   }
   MutexLock lock(&mu_);
-  GPR_ASSERT(!disconnected_);
-  disconnected_ = true;
+  GPR_ASSERT(!shutdown_);
+  shutdown_ = true;
   connector_.reset();
   connected_subchannel_.reset();
   health_watcher_map_.ShutdownLocked();
 }
 
+void Subchannel::AddDataProducer(DataProducerInterface* data_producer) {
+  MutexLock lock(&mu_);
+  auto& entry = data_producer_map_[data_producer->type()];
+  GPR_ASSERT(entry == nullptr);
+  entry = data_producer;
+}
+
+void Subchannel::RemoveDataProducer(DataProducerInterface* data_producer) {
+  MutexLock lock(&mu_);
+  auto it = data_producer_map_.find(data_producer->type());
+  GPR_ASSERT(it != data_producer_map_.end());
+  GPR_ASSERT(it->second == data_producer);
+  data_producer_map_.erase(it);
+}
+
+Subchannel::DataProducerInterface* Subchannel::GetDataProducer(
+    UniqueTypeName type) {
+  MutexLock lock(&mu_);
+  auto it = data_producer_map_.find(type);
+  if (it == data_producer_map_.end()) return nullptr;
+  return it->second;
+}
+
 namespace {
 
 // Returns a string indicating the subchannel's connectivity state change to
@@ -860,77 +887,44 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
   health_watcher_map_.NotifyLocked(state, status);
 }
 
-void Subchannel::MaybeStartConnectingLocked() {
-  if (disconnected_) {
-    // Don't try to connect if we're already disconnected.
-    return;
-  }
-  if (connecting_) {
-    // Already connecting: don't restart.
-    return;
-  }
-  if (connected_subchannel_ != nullptr) {
-    // Already connected: don't restart.
-    return;
-  }
-  connecting_ = true;
-  WeakRef(DEBUG_LOCATION, "connecting")
-      .release();  // ref held by pending connect
-  if (!backoff_begun_) {
-    backoff_begun_ = true;
-    ContinueConnectingLocked();
-  } else {
-    GPR_ASSERT(!have_retry_alarm_);
-    have_retry_alarm_ = true;
-    const Duration time_til_next =
-        next_attempt_deadline_ - ExecCtx::Get()->Now();
-    if (time_til_next <= Duration::Zero()) {
-      gpr_log(GPR_INFO, "subchannel %p %s: Retry immediately", this,
-              key_.ToString().c_str());
-    } else {
-      gpr_log(GPR_INFO, "subchannel %p %s: Retry in %" PRId64 " milliseconds",
-              this, key_.ToString().c_str(), time_til_next.millis());
-    }
-    GRPC_CLOSURE_INIT(&on_retry_alarm_, OnRetryAlarm, this,
-                      grpc_schedule_on_exec_ctx);
-    grpc_timer_init(&retry_alarm_, next_attempt_deadline_, &on_retry_alarm_);
+void Subchannel::OnRetryTimer(void* arg, grpc_error_handle /*error*/) {
+  WeakRefCountedPtr<Subchannel> c(static_cast<Subchannel*>(arg));
+  {
+    MutexLock lock(&c->mu_);
+    c->OnRetryTimerLocked();
   }
+  c.reset(DEBUG_LOCATION, "RetryTimer");
 }
 
-void Subchannel::OnRetryAlarm(void* arg, grpc_error_handle error) {
-  WeakRefCountedPtr<Subchannel> c(static_cast<Subchannel*>(arg));
-  MutexLock lock(&c->mu_);
-  c->have_retry_alarm_ = false;
-  if (c->disconnected_) {
-    error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING("Disconnected",
-                                                             &error, 1);
-  } else if (c->retry_immediately_) {
-    c->retry_immediately_ = false;
-    error = GRPC_ERROR_NONE;
-  } else {
-    (void)GRPC_ERROR_REF(error);
-  }
-  if (error == GRPC_ERROR_NONE) {
+void Subchannel::OnRetryTimerLocked() {
+  if (shutdown_) return;
+  if (connection_requested_) {
     gpr_log(GPR_INFO,
-            "subchannel %p %s: failed to connect to channel, retrying", c.get(),
-            c->key_.ToString().c_str());
-    c->ContinueConnectingLocked();
-    // Still connecting, keep ref around. Note that this stolen ref won't
-    // be dropped without first acquiring c->mu_.
-    c.release();
+            "subchannel %p %s: connection attempt requested while backoff "
+            "timer was pending, retrying now",
+            this, key_.ToString().c_str());
+    connection_requested_ = false;
+    StartConnectingLocked();
+  } else {
+    gpr_log(GPR_INFO, "subchannel %p %s: backoff delay elapsed, reporting IDLE",
+            this, key_.ToString().c_str());
+    SetConnectivityStateLocked(GRPC_CHANNEL_IDLE, absl::OkStatus());
   }
-  GRPC_ERROR_UNREF(error);
 }
 
-void Subchannel::ContinueConnectingLocked() {
+void Subchannel::StartConnectingLocked() {
+  // Set next attempt time.
+  const Timestamp min_deadline = min_connect_timeout_ + ExecCtx::Get()->Now();
+  next_attempt_time_ = backoff_.NextAttemptTime();
+  // Report CONNECTING.
+  SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING, absl::OkStatus());
+  // Start connection attempt.
   SubchannelConnector::Args args;
   args.address = &address_for_connect_;
   args.interested_parties = pollset_set_;
-  const Timestamp min_deadline = min_connect_timeout_ + ExecCtx::Get()->Now();
-  next_attempt_deadline_ = backoff_.NextAttemptTime();
-  args.deadline = std::max(next_attempt_deadline_, min_deadline);
+  args.deadline = std::max(next_attempt_time_, min_deadline);
   args.channel_args = args_;
-  SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING, absl::Status());
+  WeakRef(DEBUG_LOCATION, "Connect").release();  // Ref held by callback.
   connector_->Connect(args, &connecting_result_, &on_connecting_finished_);
 }
 
@@ -940,43 +934,49 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
       c->connecting_result_.channel_args;
   {
     MutexLock lock(&c->mu_);
-    c->connecting_ = false;
-    if (c->connecting_result_.transport != nullptr &&
-        c->PublishTransportLocked()) {
-      // Do nothing, transport was published.
-    } else if (!c->disconnected_) {
-      gpr_log(GPR_INFO, "subchannel %p %s: connect failed: %s", c.get(),
-              c->key_.ToString().c_str(), grpc_error_std_string(error).c_str());
-      c->SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
-                                    grpc_error_to_absl_status(error));
-    }
+    c->OnConnectingFinishedLocked(GRPC_ERROR_REF(error));
   }
   grpc_channel_args_destroy(delete_channel_args);
-  c.reset(DEBUG_LOCATION, "connecting");
+  c.reset(DEBUG_LOCATION, "Connect");
 }
 
-namespace {
-
-void ConnectionDestroy(void* arg, grpc_error_handle /*error*/) {
-  grpc_channel_stack* stk = static_cast<grpc_channel_stack*>(arg);
-  grpc_channel_stack_destroy(stk);
-  gpr_free(stk);
+void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
+  if (shutdown_) {
+    (void)GRPC_ERROR_UNREF(error);
+    return;
+  }
+  // If we didn't get a transport or we fail to publish it, report
+  // TRANSIENT_FAILURE and start the retry timer.
+  // Note that if the connection attempt took longer than the backoff
+  // time, then the timer will fire immediately, and we will quickly
+  // transition back to IDLE.
+  if (connecting_result_.transport == nullptr || !PublishTransportLocked()) {
+    const Duration time_until_next_attempt =
+        next_attempt_time_ - ExecCtx::Get()->Now();
+    gpr_log(GPR_INFO,
+            "subchannel %p %s: connect failed (%s), backing off for %" PRId64
+            " ms",
+            this, key_.ToString().c_str(), grpc_error_std_string(error).c_str(),
+            time_until_next_attempt.millis());
+    SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
+                               grpc_error_to_absl_status(error));
+    WeakRef(DEBUG_LOCATION, "RetryTimer").release();  // Ref held by callback.
+    grpc_timer_init(&retry_timer_, next_attempt_time_, &on_retry_timer_);
+  }
+  (void)GRPC_ERROR_UNREF(error);
 }
 
-}  // namespace
-
 bool Subchannel::PublishTransportLocked() {
   // Construct channel stack.
   ChannelStackBuilderImpl builder("subchannel", GRPC_CLIENT_SUBCHANNEL);
-  builder.SetChannelArgs(connecting_result_.channel_args)
+  builder.SetChannelArgs(ChannelArgs::FromC(connecting_result_.channel_args))
       .SetTransport(connecting_result_.transport);
   if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
     return false;
   }
-  grpc_channel_stack* stk;
-  grpc_error_handle error = builder.Build(0, 1, ConnectionDestroy, nullptr,
-                                          reinterpret_cast<void**>(&stk));
-  if (error != GRPC_ERROR_NONE) {
+  absl::StatusOr<RefCountedPtr<grpc_channel_stack>> stk = builder.Build();
+  if (!stk.ok()) {
+    auto error = absl_status_to_grpc_error(stk.status());
     grpc_transport_destroy(connecting_result_.transport);
     gpr_log(GPR_ERROR,
             "subchannel %p %s: error initializing subchannel stack: %s", this,
@@ -987,14 +987,10 @@ bool Subchannel::PublishTransportLocked() {
   RefCountedPtr<channelz::SocketNode> socket =
       std::move(connecting_result_.socket_node);
   connecting_result_.Reset();
-  if (disconnected_) {
-    grpc_channel_stack_destroy(stk);
-    gpr_free(stk);
-    return false;
-  }
+  if (shutdown_) return false;
   // Publish.
   connected_subchannel_.reset(
-      new ConnectedSubchannel(stk, args_, channelz_node_));
+      new ConnectedSubchannel(stk->release(), args_, channelz_node_));
   if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel)) {
     gpr_log(GPR_INFO, "subchannel %p %s: new connected subchannel at %p", this,
             key_.ToString().c_str(), connected_subchannel_.get());

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

@@ -19,22 +19,46 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <deque>
+#include <map>
+#include <string>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/types/optional.h"
+
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
 #include "src/core/ext/filters/client_channel/connector.h"
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/channel/context.h"
 #include "src/core/lib/gpr/time_precise.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
+#include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
@@ -183,6 +207,20 @@ class Subchannel : public DualRefCounted<Subchannel> {
         ABSL_GUARDED_BY(&mu_);
   };
 
+  // A base class for producers of subchannel-specific data.
+  // Implementations will typically add their own methods as needed.
+  class DataProducerInterface : public DualRefCounted<DataProducerInterface> {
+   public:
+    // A unique identifier for this implementation.
+    // Only one producer may be registered under a given type name on a
+    // given subchannel at any given time.
+    // Note that we use the pointer address instead of the string
+    // contents for uniqueness; all instances for a given implementation
+    // are expected to return the same string *instance*, not just the
+    // same string contents.
+    virtual UniqueTypeName type() const = 0;
+  };
+
   // Creates a subchannel.
   static RefCountedPtr<Subchannel> Create(
       OrphanablePtr<SubchannelConnector> connector,
@@ -198,6 +236,8 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // will have an affect when the subchannel creates a new ConnectedSubchannel.
   void ThrottleKeepaliveTime(int new_keepalive_time) ABSL_LOCKS_EXCLUDED(mu_);
 
+  grpc_pollset_set* pollset_set() const { return pollset_set_; }
+
   const grpc_channel_args* channel_args() const { return args_; }
 
   channelz::SubchannelNode* channelz_node();
@@ -237,7 +277,7 @@ class Subchannel : public DualRefCounted<Subchannel> {
   }
 
   // Attempt to connect to the backend.  Has no effect if already connected.
-  void AttemptToConnect() ABSL_LOCKS_EXCLUDED(mu_);
+  void RequestConnection() ABSL_LOCKS_EXCLUDED(mu_);
 
   // Resets the connection backoff of the subchannel.
   void ResetBackoff() ABSL_LOCKS_EXCLUDED(mu_);
@@ -245,6 +285,17 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // Tears down any existing connection, and arranges for destruction
   void Orphan() override ABSL_LOCKS_EXCLUDED(mu_);
 
+  // Access to data producer map.
+  // We do not hold refs to the data producer; the implementation is
+  // expected to register itself upon construction and remove itself
+  // upon destruction.
+  void AddDataProducer(DataProducerInterface* data_producer)
+      ABSL_LOCKS_EXCLUDED(mu_);
+  void RemoveDataProducer(DataProducerInterface* data_producer)
+      ABSL_LOCKS_EXCLUDED(mu_);
+  DataProducerInterface* GetDataProducer(UniqueTypeName type)
+      ABSL_LOCKS_EXCLUDED(mu_);
+
  private:
   // A linked list of ConnectivityStateWatcherInterfaces that are monitoring
   // the subchannel's state.
@@ -308,7 +359,6 @@ class Subchannel : public DualRefCounted<Subchannel> {
   };
 
   class ConnectedSubchannelStateWatcher;
-
   class AsyncWatcherNotifierLocked;
 
   // Sets the subchannel's connectivity state to \a state.
@@ -317,12 +367,14 @@ class Subchannel : public DualRefCounted<Subchannel> {
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   // Methods for connection.
-  void MaybeStartConnectingLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
-  static void OnRetryAlarm(void* arg, grpc_error_handle error)
+  static void OnRetryTimer(void* arg, grpc_error_handle error)
       ABSL_LOCKS_EXCLUDED(mu_);
-  void ContinueConnectingLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void OnRetryTimerLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  void StartConnectingLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   static void OnConnectingFinished(void* arg, grpc_error_handle error)
       ABSL_LOCKS_EXCLUDED(mu_);
+  void OnConnectingFinishedLocked(grpc_error_handle error)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
   bool PublishTransportLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
   // The subchannel pool this subchannel is in.
@@ -338,6 +390,8 @@ class Subchannel : public DualRefCounted<Subchannel> {
   grpc_pollset_set* pollset_set_;
   // Channelz tracking.
   RefCountedPtr<channelz::SubchannelNode> channelz_node_;
+  // Minimum connection timeout.
+  Duration min_connect_timeout_;
 
   // Connection state.
   OrphanablePtr<SubchannelConnector> connector_;
@@ -347,12 +401,18 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // Protects the other members.
   Mutex mu_;
 
-  // Active connection, or null.
-  RefCountedPtr<ConnectedSubchannel> connected_subchannel_ ABSL_GUARDED_BY(mu_);
-  bool connecting_ ABSL_GUARDED_BY(mu_) = false;
-  bool disconnected_ ABSL_GUARDED_BY(mu_) = false;
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
+
+  // Records if RequestConnection() was called while in backoff.
+  bool connection_requested_ ABSL_GUARDED_BY(mu_) = false;
 
   // Connectivity state tracking.
+  // Note that the connectivity state implies the state of the
+  // Subchannel object:
+  // - IDLE: no retry timer pending, can start a connection attempt at any time
+  // - CONNECTING: connection attempt in progress
+  // - READY: connection attempt succeeded, connected_subchannel_ created
+  // - TRANSIENT_FAILURE: connection attempt failed, retry timer pending
   grpc_connectivity_state state_ ABSL_GUARDED_BY(mu_) = GRPC_CHANNEL_IDLE;
   absl::Status status_ ABSL_GUARDED_BY(mu_);
   // The list of watchers without a health check service name.
@@ -360,21 +420,21 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // The map of watchers with health check service names.
   HealthWatcherMap health_watcher_map_ ABSL_GUARDED_BY(mu_);
 
-  // Minimum connect timeout - must be located before backoff_.
-  Duration min_connect_timeout_ ABSL_GUARDED_BY(mu_);
+  // Active connection, or null.
+  RefCountedPtr<ConnectedSubchannel> connected_subchannel_ ABSL_GUARDED_BY(mu_);
+
   // Backoff state.
   BackOff backoff_ ABSL_GUARDED_BY(mu_);
-  Timestamp next_attempt_deadline_ ABSL_GUARDED_BY(mu_);
-  bool backoff_begun_ ABSL_GUARDED_BY(mu_) = false;
-
-  // Retry alarm.
-  grpc_timer retry_alarm_ ABSL_GUARDED_BY(mu_);
-  grpc_closure on_retry_alarm_ ABSL_GUARDED_BY(mu_);
-  bool have_retry_alarm_ ABSL_GUARDED_BY(mu_) = false;
-  // reset_backoff() was called while alarm was pending.
-  bool retry_immediately_ ABSL_GUARDED_BY(mu_) = false;
+  Timestamp next_attempt_time_ ABSL_GUARDED_BY(mu_);
+  grpc_timer retry_timer_ ABSL_GUARDED_BY(mu_);
+  grpc_closure on_retry_timer_ ABSL_GUARDED_BY(mu_);
+
   // Keepalive time period (-1 for unset)
   int keepalive_time_ ABSL_GUARDED_BY(mu_) = -1;
+
+  // Data producer map.
+  std::map<UniqueTypeName, DataProducerInterface*> data_producer_map_
+      ABSL_GUARDED_BY(mu_);
 };
 
 }  // namespace grpc_core