grpc 1.63.0 → 1.65.2

data/src/core/client_channel/subchannel.cc

@@ -26,6 +26,8 @@
 #include <new>
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/cord.h"
 #include "absl/strings/str_cat.h"
@@ -37,25 +39,25 @@
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
+#include "src/core/channelz/channel_trace.h"
+#include "src/core/channelz/channelz.h"
+#include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
+#include "src/core/handshaker/proxy_mapper_registry.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.h"
 #include "src/core/lib/channel/channel_stack_builder_impl.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/stats_data.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/alloc.h"
-#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/debug_location.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/status_helper.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/promise/cancel_callback.h"
@@ -66,7 +68,12 @@
 #include "src/core/lib/surface/init_internally.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/interception_chain.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/stats.h"
+#include "src/core/telemetry/stats_data.h"
+#include "src/core/util/alloc.h"
+#include "src/core/util/useful.h"
 
 // Backoff parameters.
 #define GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS 1
@@ -87,83 +94,138 @@ namespace grpc_core {
 
 using ::grpc_event_engine::experimental::EventEngine;
 
-TraceFlag grpc_trace_subchannel(false, "subchannel");
-DebugOnlyTraceFlag grpc_trace_subchannel_refcount(false, "subchannel_refcount");
-
 //
 // ConnectedSubchannel
 //
 
 ConnectedSubchannel::ConnectedSubchannel(
-    grpc_channel_stack* channel_stack, const ChannelArgs& args,
+    const ChannelArgs& args,
     RefCountedPtr<channelz::SubchannelNode> channelz_subchannel)
     : RefCounted<ConnectedSubchannel>(
-          GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel_refcount)
-              ? "ConnectedSubchannel"
-              : nullptr),
-      channel_stack_(channel_stack),
+          GRPC_TRACE_FLAG_ENABLED(subchannel_refcount) ? "ConnectedSubchannel"
+                                                       : nullptr),
       args_(args),
       channelz_subchannel_(std::move(channelz_subchannel)) {}
 
-ConnectedSubchannel::~ConnectedSubchannel() {
-  GRPC_CHANNEL_STACK_UNREF(channel_stack_, "connected_subchannel_dtor");
-}
-
-void ConnectedSubchannel::StartWatch(
-    grpc_pollset_set* interested_parties,
-    OrphanablePtr<ConnectivityStateWatcherInterface> watcher) {
-  grpc_transport_op* op = grpc_make_transport_op(nullptr);
-  op->start_connectivity_watch = std::move(watcher);
-  op->start_connectivity_watch_state = GRPC_CHANNEL_READY;
-  op->bind_pollset_set = interested_parties;
-  grpc_channel_element* elem = grpc_channel_stack_element(channel_stack_, 0);
-  elem->filter->start_transport_op(elem, op);
-}
-
-void ConnectedSubchannel::Ping(grpc_closure* on_initiate,
-                               grpc_closure* on_ack) {
-  grpc_transport_op* op = grpc_make_transport_op(nullptr);
-  grpc_channel_element* elem;
-  op->send_ping.on_initiate = on_initiate;
-  op->send_ping.on_ack = on_ack;
-  elem = grpc_channel_stack_element(channel_stack_, 0);
-  elem->filter->start_transport_op(elem, op);
-}
-
-size_t ConnectedSubchannel::GetInitialCallSizeEstimate() const {
-  return GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(SubchannelCall)) +
-         channel_stack_->call_stack_size;
-}
-
-ArenaPromise<ServerMetadataHandle> ConnectedSubchannel::MakeCallPromise(
-    CallArgs call_args) {
-  // If not using channelz, we just need to call the channel stack.
-  if (channelz_subchannel() == nullptr) {
-    return channel_stack_->MakeClientCallPromise(std::move(call_args));
-  }
-  // Otherwise, we need to wrap the channel stack promise with code that
-  // handles the channelz updates.
-  return OnCancel(
-      Seq(channel_stack_->MakeClientCallPromise(std::move(call_args)),
-          [self = Ref()](ServerMetadataHandle metadata) {
-            channelz::SubchannelNode* channelz_subchannel =
-                self->channelz_subchannel();
-            GPR_ASSERT(channelz_subchannel != nullptr);
-            if (metadata->get(GrpcStatusMetadata())
-                    .value_or(GRPC_STATUS_UNKNOWN) != GRPC_STATUS_OK) {
-              channelz_subchannel->RecordCallFailed();
-            } else {
-              channelz_subchannel->RecordCallSucceeded();
-            }
-            return metadata;
-          }),
-      [self = Ref()]() {
-        channelz::SubchannelNode* channelz_subchannel =
-            self->channelz_subchannel();
-        GPR_ASSERT(channelz_subchannel != nullptr);
-        channelz_subchannel->RecordCallFailed();
-      });
-}
+//
+// LegacyConnectedSubchannel
+//
+
+class LegacyConnectedSubchannel : public ConnectedSubchannel {
+ public:
+  LegacyConnectedSubchannel(
+      RefCountedPtr<grpc_channel_stack> channel_stack, const ChannelArgs& args,
+      RefCountedPtr<channelz::SubchannelNode> channelz_subchannel)
+      : ConnectedSubchannel(args, std::move(channelz_subchannel)),
+        channel_stack_(std::move(channel_stack)) {}
+
+  ~LegacyConnectedSubchannel() override {
+    channel_stack_.reset(DEBUG_LOCATION, "ConnectedSubchannel");
+  }
+
+  void StartWatch(
+      grpc_pollset_set* interested_parties,
+      OrphanablePtr<ConnectivityStateWatcherInterface> watcher) override {
+    grpc_transport_op* op = grpc_make_transport_op(nullptr);
+    op->start_connectivity_watch = std::move(watcher);
+    op->start_connectivity_watch_state = GRPC_CHANNEL_READY;
+    op->bind_pollset_set = interested_parties;
+    grpc_channel_element* elem =
+        grpc_channel_stack_element(channel_stack_.get(), 0);
+    elem->filter->start_transport_op(elem, op);
+  }
+
+  void Ping(absl::AnyInvocable<void(absl::Status)>) override {
+    Crash("call v3 ping method called in legacy impl");
+  }
+
+  RefCountedPtr<UnstartedCallDestination> unstarted_call_destination()
+      const override {
+    Crash("call v3 unstarted_call_destination method called in legacy impl");
+  }
+
+  grpc_channel_stack* channel_stack() const override {
+    return channel_stack_.get();
+  }
+
+  size_t GetInitialCallSizeEstimate() const override {
+    return GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(SubchannelCall)) +
+           channel_stack_->call_stack_size;
+  }
+
+  void Ping(grpc_closure* on_initiate, grpc_closure* on_ack) override {
+    grpc_transport_op* op = grpc_make_transport_op(nullptr);
+    op->send_ping.on_initiate = on_initiate;
+    op->send_ping.on_ack = on_ack;
+    grpc_channel_element* elem =
+        grpc_channel_stack_element(channel_stack_.get(), 0);
+    elem->filter->start_transport_op(elem, op);
+  }
+
+ private:
+  RefCountedPtr<grpc_channel_stack> channel_stack_;
+};
+
+//
+// NewConnectedSubchannel
+//
+
+class NewConnectedSubchannel : public ConnectedSubchannel {
+ public:
+  class TransportCallDestination final : public CallDestination {
+   public:
+    explicit TransportCallDestination(OrphanablePtr<ClientTransport> transport)
+        : transport_(std::move(transport)) {}
+
+    ClientTransport* transport() { return transport_.get(); }
+
+    void HandleCall(CallHandler handler) override {
+      transport_->StartCall(std::move(handler));
+    }
+
+    void Orphaned() override { transport_.reset(); }
+
+   private:
+    OrphanablePtr<ClientTransport> transport_;
+  };
+
+  NewConnectedSubchannel(
+      RefCountedPtr<UnstartedCallDestination> call_destination,
+      RefCountedPtr<TransportCallDestination> transport,
+      const ChannelArgs& args,
+      RefCountedPtr<channelz::SubchannelNode> channelz_subchannel)
+      : ConnectedSubchannel(args, std::move(channelz_subchannel)),
+        call_destination_(std::move(call_destination)),
+        transport_(std::move(transport)) {}
+
+  void StartWatch(
+      grpc_pollset_set*,
+      OrphanablePtr<ConnectivityStateWatcherInterface> watcher) override {
+    transport_->transport()->StartConnectivityWatch(std::move(watcher));
+  }
+
+  void Ping(absl::AnyInvocable<void(absl::Status)>) override {
+    // TODO(ctiller): add new transport API for this in v3 stack
+    Crash("not implemented");
+  }
+
+  RefCountedPtr<UnstartedCallDestination> unstarted_call_destination()
+      const override {
+    return call_destination_;
+  }
+
+  grpc_channel_stack* channel_stack() const override { return nullptr; }
+
+  size_t GetInitialCallSizeEstimate() const override { return 0; }
+
+  void Ping(grpc_closure*, grpc_closure*) override {
+    Crash("legacy ping method called in call v3 impl");
+  }
+
+ private:
+  RefCountedPtr<UnstartedCallDestination> call_destination_;
+  RefCountedPtr<TransportCallDestination> transport_;
+};
 
 //
 // SubchannelCall
@@ -185,7 +247,6 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
   const grpc_call_element_args call_args = {
       callstk,              // call_stack
       nullptr,              // server_transport_data
-      args.context,         // context
       args.path.c_slice(),  // path
       args.start_time,      // start_time
       args.deadline,        // deadline
@@ -195,7 +256,7 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
   *error = grpc_call_stack_init(connected_subchannel_->channel_stack(), 1,
                                 SubchannelCall::Destroy, this, &call_args);
   if (GPR_UNLIKELY(!error->ok())) {
-    gpr_log(GPR_ERROR, "error: %s", StatusToString(*error).c_str());
+    LOG(ERROR) << "error: " << StatusToString(*error);
     return;
   }
   grpc_call_stack_set_pollset_or_pollset_set(callstk, args.pollent);
@@ -219,8 +280,8 @@ grpc_call_stack* SubchannelCall::GetCallStack() {
 }
 
 void SubchannelCall::SetAfterCallStackDestroy(grpc_closure* closure) {
-  GPR_ASSERT(after_call_stack_destroy_ == nullptr);
-  GPR_ASSERT(closure != nullptr);
+  CHECK_EQ(after_call_stack_destroy_, nullptr);
+  CHECK_NE(closure, nullptr);
   after_call_stack_destroy_ = closure;
 }
 
@@ -253,8 +314,8 @@ void SubchannelCall::Destroy(void* arg, grpc_error_handle /*error*/) {
   // Destroy the subchannel call.
   self->~SubchannelCall();
   // Destroy the call stack. This should be after destroying the subchannel
-  // call, because call->after_call_stack_destroy(), if not null, will free the
-  // call arena.
+  // call, because call->after_call_stack_destroy(), if not null, will free
+  // the call arena.
   grpc_call_stack_destroy(SUBCHANNEL_CALL_TO_CALL_STACK(self), nullptr,
                           after_call_stack_destroy);
   // Automatically reset connected_subchannel. This should be after destroying
@@ -275,7 +336,7 @@ void SubchannelCall::MaybeInterceptRecvTrailingMetadata(
   GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_, RecvTrailingMetadataReady,
                     this, grpc_schedule_on_exec_ctx);
   // save some state needed for the interception callback.
-  GPR_ASSERT(recv_trailing_metadata_ == nullptr);
+  CHECK_EQ(recv_trailing_metadata_, nullptr);
   recv_trailing_metadata_ =
       batch->payload->recv_trailing_metadata.recv_trailing_metadata;
   original_recv_trailing_metadata_ =
@@ -301,12 +362,12 @@ void GetCallStatus(grpc_status_code* status, Timestamp deadline,
 void SubchannelCall::RecvTrailingMetadataReady(void* arg,
                                                grpc_error_handle error) {
   SubchannelCall* call = static_cast<SubchannelCall*>(arg);
-  GPR_ASSERT(call->recv_trailing_metadata_ != nullptr);
+  CHECK_NE(call->recv_trailing_metadata_, nullptr);
   grpc_status_code status = GRPC_STATUS_OK;
   GetCallStatus(&status, call->deadline_, call->recv_trailing_metadata_, error);
   channelz::SubchannelNode* channelz_subchannel =
       call->connected_subchannel_->channelz_subchannel();
-  GPR_ASSERT(channelz_subchannel != nullptr);
+  CHECK_NE(channelz_subchannel, nullptr);
   if (status == GRPC_STATUS_OK) {
     channelz_subchannel->RecordCallSucceeded();
   } else {
@@ -356,7 +417,7 @@ class Subchannel::ConnectedSubchannelStateWatcher final
       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)) {
+        if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
           gpr_log(GPR_INFO,
                   "subchannel %p %s: Connected subchannel %p reports %s: %s", c,
                   c->key_.ToString().c_str(), c->connected_subchannel_.get(),
@@ -455,9 +516,9 @@ BackOff::Options ParseArgsForBackoffValues(const ChannelArgs& args,
 Subchannel::Subchannel(SubchannelKey key,
                        OrphanablePtr<SubchannelConnector> connector,
                        const ChannelArgs& args)
-    : DualRefCounted<Subchannel>(
-          GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel_refcount) ? "Subchannel"
-                                                                  : nullptr),
+    : DualRefCounted<Subchannel>(GRPC_TRACE_FLAG_ENABLED(subchannel_refcount)
+                                     ? "Subchannel"
+                                     : nullptr),
       key_(std::move(key)),
       args_(args),
       pollset_set_(grpc_pollset_set_create()),
@@ -472,8 +533,8 @@ Subchannel::Subchannel(SubchannelKey key,
   // result the subchannel destruction happens asynchronously to channel
   // destruction. If the last channel destruction triggers a grpc_shutdown
   // before the last subchannel destruction, then there maybe race conditions
-  // triggering segmentation faults. To prevent this issue, we call a grpc_init
-  // here and a grpc_shutdown in the subchannel destructor.
+  // triggering segmentation faults. To prevent this issue, we call a
+  // grpc_init here and a grpc_shutdown in the subchannel destructor.
   InitInternally();
   global_stats().IncrementClientSubchannelsCreated();
   GRPC_CLOSURE_INIT(&on_connecting_finished_, OnConnectingFinished, this,
@@ -520,7 +581,7 @@ RefCountedPtr<Subchannel> Subchannel::Create(
     const grpc_resolved_address& address, const ChannelArgs& args) {
   SubchannelKey key(address, args);
   auto* subchannel_pool = args.GetObject<SubchannelPoolInterface>();
-  GPR_ASSERT(subchannel_pool != nullptr);
+  CHECK_NE(subchannel_pool, nullptr);
   RefCountedPtr<Subchannel> c = subchannel_pool->FindSubchannel(key);
   if (c != nullptr) {
     return c;
@@ -541,7 +602,7 @@ void Subchannel::ThrottleKeepaliveTime(int new_keepalive_time) {
   // Only update the value if the new keepalive time is larger.
   if (new_keepalive_time > keepalive_time_) {
     keepalive_time_ = new_keepalive_time;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel)) {
+    if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
       gpr_log(GPR_INFO, "subchannel %p %s: throttling keepalive time to %d",
               this, key_.ToString().c_str(), new_keepalive_time);
     }
@@ -585,7 +646,8 @@ void Subchannel::CancelConnectivityStateWatch(
     watcher_list_.RemoveWatcherLocked(watcher);
   }
   // Drain any connectivity state notifications after releasing the mutex.
-  // (Shouldn't actually be necessary in this case, but better safe than sorry.)
+  // (Shouldn't actually be necessary in this case, but better safe than
+  // sorry.)
   work_serializer_.DrainQueue();
 }
 
@@ -628,7 +690,7 @@ void Subchannel::Orphaned() {
   }
   {
     MutexLock lock(&mu_);
-    GPR_ASSERT(!shutdown_);
+    CHECK(!shutdown_);
     shutdown_ = true;
     connector_.reset();
     connected_subchannel_.reset();
@@ -696,8 +758,10 @@ void Subchannel::OnRetryTimer() {
 
 void Subchannel::OnRetryTimerLocked() {
   if (shutdown_) return;
-  gpr_log(GPR_INFO, "subchannel %p %s: backoff delay elapsed, reporting IDLE",
-          this, key_.ToString().c_str());
+  if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
+    LOG(INFO) << "subchannel " << this << " " << key_.ToString()
+              << ": backoff delay elapsed, reporting IDLE";
+  }
   SetConnectivityStateLocked(GRPC_CHANNEL_IDLE, absl::OkStatus());
 }
 
@@ -741,11 +805,12 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
   if (connecting_result_.transport == nullptr || !PublishTransportLocked()) {
     const Duration time_until_next_attempt =
         next_attempt_time_ - Timestamp::Now();
-    gpr_log(GPR_INFO,
-            "subchannel %p %s: connect failed (%s), backing off for %" PRId64
-            " ms",
-            this, key_.ToString().c_str(), StatusToString(error).c_str(),
-            time_until_next_attempt.millis());
+    if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
+      LOG(INFO) << "subchannel " << this << " " << key_.ToString()
+                << ": connect failed (" << StatusToString(error)
+                << "), backing off for " << time_until_next_attempt.millis()
+                << " ms";
+    }
     SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
                                grpc_error_to_absl_status(error));
     retry_timer_handle_ = event_engine_->RunAfter(
@@ -756,11 +821,11 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
             ExecCtx exec_ctx;
             self->OnRetryTimer();
             // Subchannel deletion might require an active ExecCtx. So if
-            // self.reset() is not called here, the WeakRefCountedPtr destructor
-            // may run after the ExecCtx declared in the callback is destroyed.
-            // Since subchannel may get destroyed when the WeakRefCountedPtr
-            // destructor runs, it may not have an active ExecCtx - thus leading
-            // to crashes.
+            // self.reset() is not called here, the WeakRefCountedPtr
+            // destructor may run after the ExecCtx declared in the callback
+            // is destroyed. Since subchannel may get destroyed when the
+            // WeakRefCountedPtr destructor runs, it may not have an active
+            // ExecCtx - thus leading to crashes.
             self.reset();
           }
         });
@@ -768,37 +833,59 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
 }
 
 bool Subchannel::PublishTransportLocked() {
-  // Construct channel stack.
-  // Builder takes ownership of transport.
-  ChannelStackBuilderImpl builder(
-      "subchannel", GRPC_CLIENT_SUBCHANNEL,
-      connecting_result_.channel_args.SetObject(
-          std::exchange(connecting_result_.transport, nullptr)));
-  if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
-    return false;
-  }
-  absl::StatusOr<RefCountedPtr<grpc_channel_stack>> stk = builder.Build();
-  if (!stk.ok()) {
-    auto error = absl_status_to_grpc_error(stk.status());
-    connecting_result_.Reset();
-    gpr_log(GPR_ERROR,
-            "subchannel %p %s: error initializing subchannel stack: %s", this,
-            key_.ToString().c_str(), StatusToString(error).c_str());
-    return false;
+  auto socket_node = std::move(connecting_result_.socket_node);
+  if (connecting_result_.transport->filter_stack_transport() != nullptr) {
+    // Construct channel stack.
+    // Builder takes ownership of transport.
+    ChannelStackBuilderImpl builder(
+        "subchannel", GRPC_CLIENT_SUBCHANNEL,
+        connecting_result_.channel_args.SetObject(
+            std::exchange(connecting_result_.transport, nullptr)));
+    if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
+      return false;
+    }
+    absl::StatusOr<RefCountedPtr<grpc_channel_stack>> stack = builder.Build();
+    if (!stack.ok()) {
+      connecting_result_.Reset();
+      gpr_log(GPR_ERROR,
+              "subchannel %p %s: error initializing subchannel stack: %s", this,
+              key_.ToString().c_str(), stack.status().ToString().c_str());
+      return false;
+    }
+    connected_subchannel_ = MakeRefCounted<LegacyConnectedSubchannel>(
+        std::move(*stack), args_, channelz_node_);
+  } else {
+    OrphanablePtr<ClientTransport> transport(
+        std::exchange(connecting_result_.transport, nullptr)
+            ->client_transport());
+    InterceptionChainBuilder builder(
+        connecting_result_.channel_args.SetObject(transport.get()));
+    CoreConfiguration::Get().channel_init().AddToInterceptionChainBuilder(
+        GRPC_CLIENT_SUBCHANNEL, builder);
+    auto transport_destination =
+        MakeRefCounted<NewConnectedSubchannel::TransportCallDestination>(
+            std::move(transport));
+    auto call_destination = builder.Build(transport_destination);
+    if (!call_destination.ok()) {
+      connecting_result_.Reset();
+      gpr_log(GPR_ERROR,
+              "subchannel %p %s: error initializing subchannel stack: %s", this,
+              key_.ToString().c_str(),
+              call_destination.status().ToString().c_str());
+      return false;
+    }
+    connected_subchannel_ = MakeRefCounted<NewConnectedSubchannel>(
+        std::move(*call_destination), std::move(transport_destination), args_,
+        channelz_node_);
   }
-  RefCountedPtr<channelz::SocketNode> socket =
-      std::move(connecting_result_.socket_node);
   connecting_result_.Reset();
-  if (shutdown_) return false;
   // Publish.
-  connected_subchannel_.reset(
-      new ConnectedSubchannel(stk->release(), args_, channelz_node_));
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel)) {
+  if (GRPC_TRACE_FLAG_ENABLED(subchannel)) {
     gpr_log(GPR_INFO, "subchannel %p %s: new connected subchannel at %p", this,
             key_.ToString().c_str(), connected_subchannel_.get());
   }
   if (channelz_node_ != nullptr) {
-    channelz_node_->SetChildSocket(std::move(socket));
+    channelz_node_->SetChildSocket(std::move(socket_node));
   }
   // Start watching connected subchannel.
   connected_subchannel_->StartWatch(
@@ -809,4 +896,29 @@ bool Subchannel::PublishTransportLocked() {
   return true;
 }
 
+ChannelArgs Subchannel::MakeSubchannelArgs(
+    const ChannelArgs& channel_args, const ChannelArgs& address_args,
+    const RefCountedPtr<SubchannelPoolInterface>& subchannel_pool,
+    const std::string& channel_default_authority) {
+  // Note that we start with the channel-level args and then apply the
+  // per-address args, so that if a value is present in both, the one
+  // in the channel-level args is used.  This is particularly important
+  // for the GRPC_ARG_DEFAULT_AUTHORITY arg, which we want to allow
+  // resolvers to set on a per-address basis only if the application
+  // did not explicitly set it at the channel level.
+  return channel_args.UnionWith(address_args)
+      .SetObject(subchannel_pool)
+      // If we haven't already set the default authority arg (i.e., it
+      // was not explicitly set by the application nor overridden by
+      // the resolver), add it from the channel's default.
+      .SetIfUnset(GRPC_ARG_DEFAULT_AUTHORITY, channel_default_authority)
+      // Remove channel args that should not affect subchannel
+      // uniqueness.
+      .Remove(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME)
+      .Remove(GRPC_ARG_INHIBIT_HEALTH_CHECKING)
+      .Remove(GRPC_ARG_CHANNELZ_CHANNEL_NODE)
+      // Remove all keys with the no-subchannel prefix.
+      .RemoveAllKeysWithPrefix(GRPC_ARG_NO_SUBCHANNEL_PREFIX);
+}
+
 }  // namespace grpc_core

data/src/core/client_channel/subchannel.h

@@ -31,14 +31,11 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/connectivity_state.h>
 
-#include "src/core/client_channel/client_channel_channelz.h"
 #include "src/core/client_channel/connector.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.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"
@@ -60,35 +57,39 @@
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/util/time_precise.h"
 
 namespace grpc_core {
 
 class SubchannelCall;
 
-class ConnectedSubchannel final : public RefCounted<ConnectedSubchannel> {
+class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
  public:
-  ConnectedSubchannel(
-      grpc_channel_stack* channel_stack, const ChannelArgs& args,
-      RefCountedPtr<channelz::SubchannelNode> channelz_subchannel);
-  ~ConnectedSubchannel() override;
-
-  void StartWatch(grpc_pollset_set* interested_parties,
-                  OrphanablePtr<ConnectivityStateWatcherInterface> watcher);
-
-  void Ping(grpc_closure* on_initiate, grpc_closure* on_ack);
-
-  grpc_channel_stack* channel_stack() const { return channel_stack_; }
   const ChannelArgs& args() const { return args_; }
   channelz::SubchannelNode* channelz_subchannel() const {
     return channelz_subchannel_.get();
   }
 
-  size_t GetInitialCallSizeEstimate() const;
+  virtual void StartWatch(
+      grpc_pollset_set* interested_parties,
+      OrphanablePtr<ConnectivityStateWatcherInterface> watcher) = 0;
+
+  // Methods for v3 stack.
+  virtual void Ping(absl::AnyInvocable<void(absl::Status)> on_ack) = 0;
+  virtual RefCountedPtr<UnstartedCallDestination> unstarted_call_destination()
+      const = 0;
 
-  ArenaPromise<ServerMetadataHandle> MakeCallPromise(CallArgs call_args);
+  // Methods for legacy stack.
+  virtual grpc_channel_stack* channel_stack() const = 0;
+  virtual size_t GetInitialCallSizeEstimate() const = 0;
+  virtual void Ping(grpc_closure* on_initiate, grpc_closure* on_ack) = 0;
+
+ protected:
+  ConnectedSubchannel(
+      const ChannelArgs& args,
+      RefCountedPtr<channelz::SubchannelNode> channelz_subchannel);
 
  private:
-  grpc_channel_stack* channel_stack_;
   ChannelArgs args_;
   // ref counted pointer to the channelz node in this connected subchannel's
   // owning subchannel.
@@ -105,7 +106,6 @@ class SubchannelCall final {
     gpr_cycle_counter start_time;
     Timestamp deadline;
     Arena* arena;
-    grpc_call_context_element* context;
     CallCombiner* call_combiner;
   };
   static RefCountedPtr<SubchannelCall> Create(Args args,
@@ -244,6 +244,12 @@ class Subchannel final : public DualRefCounted<Subchannel> {
     return connected_subchannel_;
   }
 
+  RefCountedPtr<UnstartedCallDestination> call_destination() {
+    MutexLock lock(&mu_);
+    if (connected_subchannel_ == nullptr) return nullptr;
+    return connected_subchannel_->unstarted_call_destination();
+  }
+
   // Attempt to connect to the backend.  Has no effect if already connected.
   void RequestConnection() ABSL_LOCKS_EXCLUDED(mu_);
 
@@ -273,6 +279,12 @@ class Subchannel final : public DualRefCounted<Subchannel> {
     return event_engine_;
   }
 
+  // Exposed for testing purposes only.
+  static ChannelArgs MakeSubchannelArgs(
+      const ChannelArgs& channel_args, const ChannelArgs& address_args,
+      const RefCountedPtr<SubchannelPoolInterface>& subchannel_pool,
+      const std::string& channel_default_authority);
+
  private:
   // Tears down any existing connection, and arranges for destruction
   void Orphaned() override ABSL_LOCKS_EXCLUDED(mu_);

data/src/core/client_channel/subchannel_pool_interface.cc

@@ -36,8 +36,6 @@
 
 namespace grpc_core {
 
-TraceFlag grpc_subchannel_pool_trace(false, "subchannel_pool");
-
 SubchannelKey::SubchannelKey(const grpc_resolved_address& address,
                              const ChannelArgs& args)
     : address_(address), args_(args) {}