grpc 1.81.1 → 1.85.0

data/src/core/client_channel/client_channel.cc

@@ -275,39 +275,6 @@ class ClientChannel::SubchannelWrapper::WatcherWrapper
         << subchannel_wrapper_->subchannel_.get()
         << " watcher=" << watcher_.get()
         << " state=" << ConnectivityStateName(state) << " status=" << status;
-    if (!IsSubchannelConnectionScalingEnabled()) {
-      auto keepalive_throttling = status.GetPayload(kKeepaliveThrottlingKey);
-      if (keepalive_throttling.has_value()) {
-        int new_keepalive_time_ms = -1;
-        if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
-                             &new_keepalive_time_ms)) {
-          Duration new_keepalive_time =
-              Duration::Milliseconds(new_keepalive_time_ms);
-          if (new_keepalive_time >
-              subchannel_wrapper_->client_channel_->keepalive_time_) {
-            subchannel_wrapper_->client_channel_->keepalive_time_ =
-                new_keepalive_time;
-            GRPC_TRACE_LOG(client_channel, INFO)
-                << "client_channel="
-                << subchannel_wrapper_->client_channel_.get()
-                << ": throttling keepalive time to "
-                << subchannel_wrapper_->client_channel_->keepalive_time_;
-            // Propagate the new keepalive time to all subchannels. This is so
-            // that new transports created by any subchannel (and not just the
-            // subchannel that received the GOAWAY), use the new keepalive time.
-            for (auto& [subchannel, _] :
-                 subchannel_wrapper_->client_channel_->subchannel_map_) {
-              subchannel->ThrottleKeepaliveTime(new_keepalive_time);
-            }
-          }
-        } else {
-          LOG(ERROR) << "client_channel="
-                     << subchannel_wrapper_->client_channel_.get()
-                     << ": Illegal keepalive throttling value "
-                     << std::string(keepalive_throttling.value());
-        }
-      }
-    }
     // Propagate status only in state TF.
     // We specifically want to avoid propagating the status for
     // state IDLE that the real subchannel gave us only for the
@@ -404,20 +371,18 @@ void ClientChannel::SubchannelWrapper::Orphaned() {
           }
           self->client_channel_->subchannel_map_.erase(it);
         }
-        if (IsSubchannelWrapperCleanupOnOrphanEnabled()) {
-          // We need to make sure that the internal subchannel gets unreffed
-          // inside of the WorkSerializer, so that updates to the local
-          // subchannel pool are properly synchronized.  To that end, we
-          // drop our ref to the internal subchannel here.  We also cancel
-          // any watchers that were not properly cancelled, in case any of
-          // them are holding a ref to the internal subchannel.
-          for (const auto& [_, watcher] : self->watcher_map_) {
-            self->subchannel_->CancelConnectivityStateWatch(watcher);
-          }
-          self->watcher_map_.clear();
-          self->data_watchers_.clear();
-          self->subchannel_.reset();
+        // We need to make sure that the internal subchannel gets unreffed
+        // inside of the WorkSerializer, so that updates to the local
+        // subchannel pool are properly synchronized.  To that end, we
+        // drop our ref to the internal subchannel here.  We also cancel
+        // any watchers that were not properly cancelled, in case any of
+        // them are holding a ref to the internal subchannel.
+        for (const auto& [_, watcher] : self->watcher_map_) {
+          self->subchannel_->CancelConnectivityStateWatch(watcher);
         }
+        self->watcher_map_.clear();
+        self->data_watchers_.clear();
+        self->subchannel_.reset();
       });
 }
 
@@ -588,6 +553,12 @@ absl::StatusOr<RefCountedPtr<Channel>> ClientChannel::Create(
   if (target.empty()) {
     return absl::InternalError("target URI is empty in client channel");
   }
+  auto channel_args_mutator =
+      grpc_channel_args_get_client_channel_creation_mutator();
+  if (channel_args_mutator != nullptr) {
+    channel_args =
+        channel_args_mutator(target.c_str(), channel_args, GRPC_CLIENT_CHANNEL);
+  }
   std::string uri_to_resolve = CoreConfiguration::Get()
                                    .proxy_mapper_registry()
                                    .MapName(target, &channel_args)
@@ -747,7 +718,7 @@ class ExternalStateWatcher : public RefCounted<ExternalStateWatcher> {
                        Timestamp deadline)
       : channel_(std::move(channel)), cq_(cq), tag_(tag) {
     grpc_cq_begin_op(cq, tag);
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     // Start watch.  This inherits the ref from creation.
     auto watcher =
         MakeOrphanable<Watcher>(RefCountedPtr<ExternalStateWatcher>(this));
@@ -785,7 +756,7 @@ class ExternalStateWatcher : public RefCounted<ExternalStateWatcher> {
   // on the first call.  Subsequent calls will be ignored, because
   // events can come in asynchronously.
   void MaybeStartCompletion(absl::Status status) {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     if (watcher_ == nullptr) return;  // Ignore subsequent notifications.
     // Cancel watch.
     channel_->RemoveConnectivityWatcher(watcher_);
@@ -847,7 +818,7 @@ void ClientChannel::RemoveConnectivityWatcher(
 }
 
 void ClientChannel::GetInfo(const grpc_channel_info* info) {
-  MutexLock lock(&info_mu_);
+  MutexLock lock(info_mu_);
   if (info->lb_policy_name != nullptr) {
     *info->lb_policy_name = gpr_strdup(info_lb_policy_name_.c_str());
   }
@@ -898,10 +869,15 @@ void ClientChannel::Ping(grpc_completion_queue*, void*) {
 grpc_call* ClientChannel::CreateCall(
     grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* /*pollset_set_alternative*/,
-    Slice path, std::optional<Slice> authority, Timestamp deadline, bool) {
+    Slice path, std::optional<Slice> authority, Timestamp deadline,
+    bool /*registered_method*/,
+    std::optional<absl::FunctionRef<void(Arena*)>> arena_init_function) {
   auto arena = call_arena_allocator()->MakeArena();
   arena->SetContext<grpc_event_engine::experimental::EventEngine>(
       event_engine());
+  if (arena_init_function.has_value()) {
+    (*arena_init_function)(arena.get());
+  }
   return MakeClientCall(parent_call, propagation_mask, cq, std::move(path),
                         std::move(authority), false, deadline,
                         compression_options(), std::move(arena), Ref());
@@ -924,12 +900,10 @@ class FilterChainBuilderImpl final : public FilterChainBuilder {
  public:
   FilterChainBuilderImpl(
       bool enable_retries, const ChannelArgs& channel_args,
-      Blackboard* blackboard,
       std::function<void(ServerMetadata&)> on_server_trailing_metadata,
       RefCountedPtr<UnstartedCallDestination> destination)
       : enable_retries_(enable_retries),
         channel_args_(channel_args),
-        blackboard_(blackboard),
         on_server_trailing_metadata_(std::move(on_server_trailing_metadata)),
         destination_(std::move(destination)) {}
 
@@ -954,8 +928,7 @@ class FilterChainBuilderImpl final : public FilterChainBuilder {
   }
 
   void InitBuilder() {
-    builder_ =
-        std::make_unique<InterceptionChainBuilder>(channel_args_, blackboard_);
+    builder_ = std::make_unique<InterceptionChainBuilder>(channel_args_);
     if (on_server_trailing_metadata_ != nullptr) {
       builder_->AddOnServerTrailingMetadata(on_server_trailing_metadata_);
     }
@@ -965,7 +938,6 @@ class FilterChainBuilderImpl final : public FilterChainBuilder {
 
   const bool enable_retries_;
   const ChannelArgs channel_args_;
-  const Blackboard* blackboard_;
   const std::function<void(ServerMetadata&)> on_server_trailing_metadata_;
   const RefCountedPtr<UnstartedCallDestination> destination_;
   std::unique_ptr<InterceptionChainBuilder> builder_;
@@ -1373,7 +1345,7 @@ void ClientChannel::UpdateServiceConfigInControlPlaneLocked(
   saved_config_selector_ = std::move(config_selector);
   // Update the data used by GetChannelInfo().
   {
-    MutexLock lock(&info_mu_);
+    MutexLock lock(info_mu_);
     info_lb_policy_name_ = std::move(lb_policy_name);
     info_service_config_json_ = std::move(service_config_json);
   }
@@ -1392,15 +1364,13 @@ void ClientChannel::UpdateServiceConfigInDataPlaneLocked(
   }
   // Modify channel args.
   ChannelArgs new_args = args.SetObject(this).SetObject(saved_service_config_);
-  // Construct filter stack.
-  auto new_blackboard = MakeRefCounted<Blackboard>();
   const bool enable_retries =
       !channel_args_.WantMinimalStack() &&
       channel_args_.GetBool(GRPC_ARG_ENABLE_RETRIES).value_or(true);
   if (enable_retries) {
-    RetryInterceptor::UpdateBlackboard(*saved_service_config_,
-                                       blackboard_.get(), new_blackboard.get());
+    retry_throttler_updater_.Update(*saved_service_config_, new_args);
   }
+  // Construct filter stack.
   std::function<void(ServerMetadata&)> on_server_trailing_metadata;
   if (idle_timeout_ != Duration::Zero()) {
     on_server_trailing_metadata = [this](ServerMetadata&) {
@@ -1408,11 +1378,9 @@ void ClientChannel::UpdateServiceConfigInDataPlaneLocked(
     };
   }
   FilterChainBuilderImpl filter_chain_builder(
-      enable_retries, new_args, new_blackboard.get(),
-      std::move(on_server_trailing_metadata), call_destination_);
-  config_selector->BuildFilterChains(filter_chain_builder, blackboard_.get(),
-                                     new_blackboard.get());
-  blackboard_ = std::move(new_blackboard);
+      enable_retries, new_args, std::move(on_server_trailing_metadata),
+      call_destination_);
+  config_selector->BuildFilterChains(filter_chain_builder);
   resolver_data_for_calls_.Set(std::move(config_selector));
 }
 

data/src/core/client_channel/client_channel.h

@@ -22,9 +22,9 @@
 #include "src/core/call/metadata.h"
 #include "src/core/client_channel/client_channel_factory.h"
 #include "src/core/client_channel/config_selector.h"
+#include "src/core/client_channel/retry_throttle.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/ext/filters/channel_idle/idle_filter_state.h"
-#include "src/core/filter/blackboard.h"
 #include "src/core/lib/promise/observable.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/load_balancing/lb_policy.h"
@@ -75,7 +75,9 @@ class ClientChannel : public Channel {
                         grpc_completion_queue* cq,
                         grpc_pollset_set* /*pollset_set_alternative*/,
                         Slice path, std::optional<Slice> authority,
-                        Timestamp deadline, bool registered_method) override;
+                        Timestamp deadline, bool registered_method,
+                        std::optional<absl::FunctionRef<void(Arena*)>>
+                            arena_init_function) override;
 
   void StartCall(UnstartedCallHandler unstarted_handler) override;
 
@@ -213,7 +215,7 @@ class ClientChannel : public Channel {
       ABSL_GUARDED_BY(*work_serializer_);
   RefCountedPtr<ConfigSelector> saved_config_selector_
       ABSL_GUARDED_BY(*work_serializer_);
-  RefCountedPtr<const Blackboard> blackboard_
+  RetryThrottlerChannelArgsUpdater retry_throttler_updater_
       ABSL_GUARDED_BY(*work_serializer_);
   OrphanablePtr<LoadBalancingPolicy> lb_policy_
       ABSL_GUARDED_BY(*work_serializer_);

data/src/core/client_channel/client_channel_filter.cc

@@ -465,20 +465,18 @@ class ClientChannelFilter::SubchannelWrapper final
             }
             chand_->subchannel_map_.erase(it);
           }
-          if (IsSubchannelWrapperCleanupOnOrphanEnabled()) {
-            // We need to make sure that the internal subchannel gets unreffed
-            // inside of the WorkSerializer, so that updates to the local
-            // subchannel pool are properly synchronized.  To that end, we
-            // drop our ref to the internal subchannel here.  We also cancel
-            // any watchers that were not properly cancelled, in case any of
-            // them are holding a ref to the internal subchannel.
-            for (const auto& [_, watcher] : watcher_map_) {
-              subchannel_->CancelConnectivityStateWatch(watcher);
-            }
-            watcher_map_.clear();
-            data_watchers_.clear();
-            subchannel_.reset();
+          // We need to make sure that the internal subchannel gets unreffed
+          // inside of the WorkSerializer, so that updates to the local
+          // subchannel pool are properly synchronized.  To that end, we
+          // drop our ref to the internal subchannel here.  We also cancel
+          // any watchers that were not properly cancelled, in case any of
+          // them are holding a ref to the internal subchannel.
+          for (const auto& [_, watcher] : watcher_map_) {
+            subchannel_->CancelConnectivityStateWatch(watcher);
           }
+          watcher_map_.clear();
+          data_watchers_.clear();
+          subchannel_.reset();
           WeakUnref(DEBUG_LOCATION, "subchannel map cleanup");
         });
   }
@@ -604,35 +602,6 @@ class ClientChannelFilter::SubchannelWrapper final
           << parent_.get() << " subchannel " << parent_->subchannel_.get()
           << " watcher=" << watcher_.get()
           << " state=" << ConnectivityStateName(state) << " status=" << status;
-      if (!IsSubchannelConnectionScalingEnabled()) {
-        auto keepalive_throttling = status.GetPayload(kKeepaliveThrottlingKey);
-        if (keepalive_throttling.has_value()) {
-          int new_keepalive_time_ms = -1;
-          if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
-                               &new_keepalive_time_ms)) {
-            Duration new_keepalive_time =
-                Duration::Milliseconds(new_keepalive_time_ms);
-            if (new_keepalive_time > parent_->chand_->keepalive_time_) {
-              parent_->chand_->keepalive_time_ = new_keepalive_time;
-              GRPC_TRACE_LOG(client_channel, INFO)
-                  << "chand=" << parent_->chand_
-                  << ": throttling keepalive time to "
-                  << parent_->chand_->keepalive_time_;
-              // Propagate the new keepalive time to all subchannels. This is
-              // so that new transports created by any subchannel (and not
-              // just the subchannel that received the GOAWAY), use the new
-              // keepalive time.
-              for (auto& [subchannel, _] : parent_->chand_->subchannel_map_) {
-                subchannel->ThrottleKeepaliveTime(new_keepalive_time);
-              }
-            }
-          } else {
-            LOG(ERROR) << "chand=" << parent_->chand_
-                       << ": Illegal keepalive throttling value "
-                       << std::string(keepalive_throttling.value());
-          }
-        }
-      }
       // Propagate status only in state TF.
       // We specifically want to avoid propagating the status for
       // state IDLE that the real subchannel gave us only for the
@@ -714,7 +683,7 @@ ClientChannelFilter::ExternalConnectivityWatcher::ExternalConnectivityWatcher(
                                          chand_->interested_parties_);
   GRPC_CHANNEL_STACK_REF(chand_->owning_stack_, "ExternalConnectivityWatcher");
   {
-    MutexLock lock(&chand_->external_watchers_mu_);
+    MutexLock lock(chand_->external_watchers_mu_);
     // Will be deleted when the watch is complete.
     GRPC_CHECK(chand->external_watchers_[on_complete] == nullptr);
     // Store a ref to the watcher in the external_watchers_ map.
@@ -744,7 +713,7 @@ void ClientChannelFilter::ExternalConnectivityWatcher::
                                          bool cancel) {
   RefCountedPtr<ExternalConnectivityWatcher> watcher;
   {
-    MutexLock lock(&chand->external_watchers_mu_);
+    MutexLock lock(chand->external_watchers_mu_);
     auto it = chand->external_watchers_.find(on_complete);
     if (it != chand->external_watchers_.end()) {
       watcher = std::move(it->second);
@@ -1045,7 +1014,7 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
   auto service_config =
       ServiceConfigImpl::Create(channel_args_, *service_config_json);
   if (!service_config.ok()) {
-    *error = absl_status_to_grpc_error(service_config.status());
+    *error = service_config.status();
     return;
   }
   default_service_config_ = std::move(*service_config);
@@ -1330,7 +1299,7 @@ void ClientChannelFilter::OnResolverErrorLocked(absl::Status status) {
     UpdateStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE, status,
                       "resolver failure");
     {
-      MutexLock lock(&resolution_mu_);
+      MutexLock lock(resolution_mu_);
       // Update resolver transient failure.
       resolver_transient_failure_error_ =
           MaybeRewriteIllegalStatusCode(status, "resolver");
@@ -1406,7 +1375,7 @@ void ClientChannelFilter::UpdateServiceConfigInControlPlaneLocked(
   saved_service_config_ = std::move(service_config);
   // Swap out the data used by GetChannelInfo().
   {
-    MutexLock lock(&info_mu_);
+    MutexLock lock(info_mu_);
     info_lb_policy_name_ = std::move(lb_policy_name);
     info_service_config_json_ = std::move(service_config_json);
   }
@@ -1422,11 +1391,8 @@ namespace {
 // Filter chain builder impl to inject into ConfigSelector.
 class LegacyFilterChainBuilder final : public FilterChainBuilder {
  public:
-  LegacyFilterChainBuilder(bool enable_retries, const ChannelArgs& channel_args,
-                           const Blackboard* blackboard)
-      : enable_retries_(enable_retries),
-        channel_args_(channel_args),
-        blackboard_(blackboard) {}
+  LegacyFilterChainBuilder(bool enable_retries, const ChannelArgs& channel_args)
+      : enable_retries_(enable_retries), channel_args_(channel_args) {}
 
   absl::StatusOr<RefCountedPtr<FilterChain>> Build() override {
     if (enable_retries_) {
@@ -1435,7 +1401,7 @@ class LegacyFilterChainBuilder final : public FilterChainBuilder {
       filters_.push_back({&DynamicTerminationFilter::kFilterVtable, nullptr});
     }
     RefCountedPtr<DynamicFilters> dynamic_filters =
-        DynamicFilters::Create(channel_args_, std::move(filters_), blackboard_);
+        DynamicFilters::Create(channel_args_, std::move(filters_));
     if (dynamic_filters == nullptr) {
       return absl::InternalError("error constructing dynamic filter stack");
     }
@@ -1451,7 +1417,6 @@ class LegacyFilterChainBuilder final : public FilterChainBuilder {
 
   const bool enable_retries_;
   const ChannelArgs channel_args_;
-  const Blackboard* blackboard_;
   std::vector<FilterAndConfig> filters_;
 };
 
@@ -1475,23 +1440,18 @@ void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked(
   bool enable_retries =
       !new_args.WantMinimalStack() &&
       new_args.GetBool(GRPC_ARG_ENABLE_RETRIES).value_or(true);
-  // Construct dynamic filter stack.
-  auto new_blackboard = MakeRefCounted<Blackboard>();
   if (enable_retries) {
-    RetryFilter::UpdateBlackboard(*service_config, blackboard_.get(),
-                                  new_blackboard.get());
-  }
-  LegacyFilterChainBuilder filter_chain_builder(enable_retries, new_args,
-                                                new_blackboard.get());
-  config_selector->BuildFilterChains(filter_chain_builder, blackboard_.get(),
-                                     new_blackboard.get());
-  blackboard_ = std::move(new_blackboard);
+    retry_throttler_updater_.Update(*service_config, new_args);
+  }
+  // Construct dynamic filter stack.
+  LegacyFilterChainBuilder filter_chain_builder(enable_retries, new_args);
+  config_selector->BuildFilterChains(filter_chain_builder);
   // Grab data plane lock to update service config.
   //
   // We defer unreffing the old values (and deallocating memory) until
   // after releasing the lock to keep the critical section small.
   {
-    MutexLock lock(&resolution_mu_);
+    MutexLock lock(resolution_mu_);
     resolver_transient_failure_error_ = absl::OkStatus();
     // Update service config.
     received_service_config_data_ = true;
@@ -1536,7 +1496,7 @@ void ClientChannelFilter::DestroyResolverAndLbPolicyLocked() {
     RefCountedPtr<ServiceConfig> service_config_to_unref;
     RefCountedPtr<ConfigSelector> config_selector_to_unref;
     {
-      MutexLock lock(&resolution_mu_);
+      MutexLock lock(resolution_mu_);
       received_service_config_data_ = false;
       service_config_to_unref = std::move(service_config_);
       config_selector_to_unref = std::move(config_selector_);
@@ -1566,12 +1526,12 @@ void ClientChannelFilter::UpdateStateLocked(grpc_connectivity_state state,
     if (!status.ok() || state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
       GRPC_CHANNELZ_LOG(channelz_node_)
           << channelz::ChannelNode::GetChannelConnectivityStateChangeString(
-                 state);
+                 state)
+          << " status: " << status.ToString();
     } else {
       GRPC_CHANNELZ_LOG(channelz_node_)
           << channelz::ChannelNode::GetChannelConnectivityStateChangeString(
-                 state)
-          << " status: " << status.ToString();
+                 state);
     }
   }
 }
@@ -1584,7 +1544,7 @@ void ClientChannelFilter::UpdateStateAndPickerLocked(
   // Grab the LB lock to update the picker and trigger reprocessing of the
   // queued picks.
   // Old picker will be unreffed after releasing the lock.
-  MutexLock lock(&lb_mu_);
+  MutexLock lock(lb_mu_);
   picker_.swap(picker);
   // Reprocess queued picks.
   for (auto& call : lb_queued_calls_) {
@@ -1634,7 +1594,7 @@ grpc_error_handle ClientChannelFilter::DoPingLocked(grpc_transport_op* op) {
   }
   LoadBalancingPolicy::PickResult result;
   {
-    MutexLock lock(&lb_mu_);
+    MutexLock lock(lb_mu_);
     result = picker_->Pick(LoadBalancingPolicy::PickArgs());
   }
   return HandlePickResult<grpc_error_handle>(
@@ -1654,11 +1614,11 @@ grpc_error_handle ClientChannelFilter::DoPingLocked(grpc_transport_op* op) {
       },
       // Fail pick.
       [](LoadBalancingPolicy::PickResult::Fail* fail_pick) {
-        return absl_status_to_grpc_error(fail_pick->status);
+        return fail_pick->status;
       },
       // Drop pick.
       [](LoadBalancingPolicy::PickResult::Drop* drop_pick) {
-        return absl_status_to_grpc_error(drop_pick->status);
+        return drop_pick->status;
       });
 }
 
@@ -1694,11 +1654,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
         << "chand=" << this << ": disconnect_with_error: "
         << StatusToString(op->disconnect_with_error);
     DestroyResolverAndLbPolicyLocked();
-    intptr_t value;
-    if (grpc_error_get_int(op->disconnect_with_error,
-                           StatusIntProperty::ChannelConnectivityState,
-                           &value) &&
-        static_cast<grpc_connectivity_state>(value) == GRPC_CHANNEL_IDLE) {
+    if (op->go_idle) {
       if (disconnect_error_.ok()) {  // Ignore if we're shutting down.
         // Enter IDLE state.
         UpdateStateAndPickerLocked(GRPC_CHANNEL_IDLE, absl::Status(),
@@ -1714,7 +1670,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
       UpdateStateAndPickerLocked(
           GRPC_CHANNEL_SHUTDOWN, absl::Status(), "shutdown from API",
           MakeRefCounted<LoadBalancingPolicy::TransientFailurePicker>(
-              grpc_error_to_absl_status(op->disconnect_with_error)));
+              op->disconnect_with_error));
       // TODO(roth): If this happens when we're still waiting for a
       // resolver result, we need to trigger failures for all calls in
       // the resolver queue here.
@@ -1743,7 +1699,7 @@ void ClientChannelFilter::StartTransportOp(grpc_channel_element* elem,
 void ClientChannelFilter::GetChannelInfo(grpc_channel_element* elem,
                                          const grpc_channel_info* info) {
   auto* chand = static_cast<ClientChannelFilter*>(elem->channel_data);
-  MutexLock lock(&chand->info_mu_);
+  MutexLock lock(chand->info_mu_);
   if (info->lb_policy_name != nullptr) {
     *info->lb_policy_name = gpr_strdup(chand->info_lb_policy_name_.c_str());
   }
@@ -1811,7 +1767,7 @@ class ClientChannelFilter::CallData::ResolverQueuedCallCanceller final {
     auto* calld = self->calld_;
     auto* chand = calld->chand();
     {
-      MutexLock lock(&chand->resolution_mu_);
+      MutexLock lock(chand->resolution_mu_);
       GRPC_TRACE_LOG(client_channel_call, INFO)
           << "chand=" << chand << " calld=" << calld
           << ": cancelling resolver queued pick: "
@@ -1886,8 +1842,8 @@ grpc_error_handle ClientChannelFilter::CallData::ApplyServiceConfigToCallLocked(
                           ->GetCallConfig({send_initial_metadata(), arena_,
                                            service_config_call_data});
   if (!filter_chain.ok()) {
-    return absl_status_to_grpc_error(
-        MaybeRewriteIllegalStatusCode(filter_chain.status(), "ConfigSelector"));
+    return MaybeRewriteIllegalStatusCode(filter_chain.status(),
+                                         "ConfigSelector");
   }
   dynamic_filters_ = filter_chain->TakeAsSubclass<const DynamicFilters>();
   // Apply our own method params to the call.
@@ -1917,7 +1873,7 @@ std::optional<absl::Status> ClientChannelFilter::CallData::CheckResolution(
   // Check if we have a resolver result to use.
   absl::StatusOr<RefCountedPtr<ConfigSelector>> config_selector;
   {
-    MutexLock lock(&chand()->resolution_mu_);
+    MutexLock lock(chand()->resolution_mu_);
     bool result_ready = CheckResolutionLocked(&config_selector);
     // If no result is available, queue the call.
     if (!result_ready) {
@@ -1957,7 +1913,7 @@ bool ClientChannelFilter::CallData::CheckResolutionLocked(
       GRPC_TRACE_LOG(client_channel_call, INFO)
           << "chand=" << chand() << " calld=" << this
           << ": resolution failed, failing call";
-      *config_selector = absl_status_to_grpc_error(resolver_error);
+      *config_selector = resolver_error;
       return true;
     }
     // Either the resolver has not yet returned a result, or it has
@@ -2283,7 +2239,7 @@ class ClientChannelFilter::LoadBalancedCall::LbQueuedCallCanceller final {
     auto* lb_call = self->lb_call_.get();
     auto* chand = lb_call->chand_;
     {
-      MutexLock lock(&chand->lb_mu_);
+      MutexLock lock(chand->lb_mu_);
       GRPC_TRACE_LOG(client_channel_lb_call, INFO)
           << "chand=" << chand << " lb_call=" << lb_call
           << ": cancelling queued pick: error=" << StatusToString(error)
@@ -2437,7 +2393,7 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
       << "chand=" << chand_ << " lb_call=" << this
       << ": grabbing LB mutex to get picker";
   {
-    MutexLock lock(&chand_->lb_mu_);
+    MutexLock lock(chand_->lb_mu_);
     picker = chand_->picker_;
   }
   while (true) {
@@ -2457,7 +2413,7 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
     bool pick_complete = PickSubchannelImpl(picker.get(), &error);
     if (!pick_complete) {
       RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> old_picker;
-      MutexLock lock(&chand_->lb_mu_);
+      MutexLock lock(chand_->lb_mu_);
       // If picker has been swapped out since we grabbed it, try again.
       if (picker != chand_->picker_) {
         GRPC_TRACE_LOG(client_channel_lb_call, INFO)
@@ -2493,6 +2449,9 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
 bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
     LoadBalancingPolicy::SubchannelPicker* picker, grpc_error_handle* error) {
   GRPC_CHECK(subchannel_call_ == nullptr);
+  // Adding the call arena to TLS so that LB pickers can access call context
+  // from the arena.
+  promise_detail::Context<Arena> arena_ctx(arena_);
   // Perform LB pick.
   LoadBalancingPolicy::PickArgs pick_args;
   Slice* path = send_initial_metadata()->get_pointer(HttpPathMetadata());
@@ -2565,8 +2524,8 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
         if (!send_initial_metadata()
                  ->GetOrCreatePointer(WaitForReady())
                  ->value) {
-          *error = absl_status_to_grpc_error(MaybeRewriteIllegalStatusCode(
-              std::move(fail_pick->status), "LB pick"));
+          *error = MaybeRewriteIllegalStatusCode(std::move(fail_pick->status),
+                                                 "LB pick");
           return true;
         }
         // If wait_for_ready is true, then queue to retry when we get a new
@@ -2578,10 +2537,9 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
         GRPC_TRACE_LOG(client_channel_lb_call, INFO)
             << "chand=" << chand_ << " lb_call=" << this
             << ": LB pick dropped: " << drop_pick->status;
-        *error = grpc_error_set_int(
-            absl_status_to_grpc_error(MaybeRewriteIllegalStatusCode(
-                std::move(drop_pick->status), "LB drop")),
-            StatusIntProperty::kLbPolicyDrop, 1);
+        is_drop_ = true;
+        *error = MaybeRewriteIllegalStatusCode(std::move(drop_pick->status),
+                                               "LB drop");
         return true;
       });
 }
@@ -2719,7 +2677,7 @@ void ClientChannelFilter::LoadBalancedCall::RecvTrailingMetadataReady(
       << " call_attempt_tracer_=" << self->call_attempt_tracer_
       << " lb_subchannel_call_tracker_="
       << self->lb_subchannel_call_tracker_.get()
-      << " failure_error_=" << StatusToString(self->failure_error_);
+      << " is_drop_=" << self->is_drop_;
   // Check if we have a tracer or an LB callback to invoke.
   if (self->call_attempt_tracer_ != nullptr ||
       self->lb_subchannel_call_tracker_ != nullptr) {
@@ -2753,11 +2711,9 @@ void ClientChannelFilter::LoadBalancedCall::RecvTrailingMetadataReady(
     self->RecordCallCompletion(status, self->recv_trailing_metadata_,
                                self->transport_stream_stats_, peer_string);
   }
+  // If we dropped the call, indicate that fact in the metadata.
+  if (self->is_drop_) self->recv_trailing_metadata_->Set(LbPolicyDrop(), true);
   // Chain to original callback.
-  if (!self->failure_error_.ok()) {
-    error = self->failure_error_;
-    self->failure_error_ = absl::OkStatus();
-  }
   Closure::Run(DEBUG_LOCATION, self->original_recv_trailing_metadata_ready_,
                error);
 }

data/src/core/client_channel/client_channel_filter.h

@@ -36,9 +36,9 @@
 #include "src/core/client_channel/client_channel_factory.h"
 #include "src/core/client_channel/config_selector.h"
 #include "src/core/client_channel/dynamic_filters.h"
+#include "src/core/client_channel/retry_throttle.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
-#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -300,7 +300,7 @@ class ClientChannelFilter final {
       ABSL_GUARDED_BY(*work_serializer_);
   RefCountedPtr<ConfigSelector> saved_config_selector_
       ABSL_GUARDED_BY(*work_serializer_);
-  RefCountedPtr<const Blackboard> blackboard_
+  RetryThrottlerChannelArgsUpdater retry_throttler_updater_
       ABSL_GUARDED_BY(*work_serializer_);
   OrphanablePtr<LoadBalancingPolicy> lb_policy_
       ABSL_GUARDED_BY(*work_serializer_);
@@ -450,8 +450,8 @@ class ClientChannelFilter::LoadBalancedCall final
   // Set when we get a cancel_stream op.
   grpc_error_handle cancel_error_;
 
-  // Set when we fail inside the LB call.
-  grpc_error_handle failure_error_;
+  // Set when the LB picker returns a drop result.
+  bool is_drop_ = false;
 
   LbQueuedCallCanceller* lb_call_canceller_
       ABSL_GUARDED_BY(&ClientChannelFilter::lb_mu_) = nullptr;

data/src/core/client_channel/client_channel_plugin.cc

@@ -32,7 +32,7 @@ namespace grpc_core {
 
 void BuildClientChannelConfiguration(CoreConfiguration::Builder* builder) {
   internal::ClientChannelServiceConfigParser::Register(builder);
-  internal::RetryServiceConfigParser::Register(builder);
+  RetryServiceConfigParser::Register(builder);
   builder->channel_init()
       ->RegisterV2Filter<ClientChannelFilter>(GRPC_CLIENT_CHANNEL)
       .Terminal();