grpc 1.84.0 → 1.85.0.pre1

data/src/core/load_balancing/autosharding/autosharding.h

@@ -0,0 +1,78 @@
+//
+// Copyright 2026 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_SRC_CORE_LOAD_BALANCING_AUTOSHARDING_AUTOSHARDING_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_AUTOSHARDING_AUTOSHARDING_H
+
+#include <string>
+
+#include "src/core/load_balancing/lb_policy.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
+#include "src/core/util/ref_counted_string.h"
+#include "src/core/util/time.h"
+#include "src/core/util/validation_errors.h"
+#include "absl/strings/string_view.h"
+
+// TODO(bpawan): Expose Channel Factory types once defined for C++ (gRFC A119).
+
+namespace grpc_core {
+
+class AutoShardingLbConfig final : public LoadBalancingPolicy::Config {
+ public:
+  AutoShardingLbConfig() = default;
+
+  AutoShardingLbConfig(const AutoShardingLbConfig&) = delete;
+  AutoShardingLbConfig& operator=(const AutoShardingLbConfig&) = delete;
+
+  AutoShardingLbConfig(AutoShardingLbConfig&& other) = delete;
+  AutoShardingLbConfig& operator=(AutoShardingLbConfig&& other) = delete;
+
+  absl::string_view name() const override;
+
+  const std::string& channel_factory_key() const {
+    return channel_factory_key_;
+  }
+  const std::string& autosharding_target() const {
+    return autosharding_target_;
+  }
+  const RefCountedStringValue& key_header_name() const {
+    return key_header_name_;
+  }
+  bool enable_fallback() const { return enable_fallback_; }
+  // TODO(bpawan): Pass this to the autosharding client, which will own the
+  // initial assignment timer (gRFC A119).
+  Duration initial_assignment_timeout() const {
+    return initial_assignment_timeout_;
+  }
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs& args);
+
+  void JsonPostLoad(const Json& json, const JsonArgs& args,
+                    ValidationErrors* errors);
+
+ private:
+  std::string channel_factory_key_;
+  std::string autosharding_target_;
+  RefCountedStringValue key_header_name_;
+  bool enable_fallback_ = false;
+  Duration initial_assignment_timeout_ = Duration::Seconds(60);
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_AUTOSHARDING_AUTOSHARDING_H

data/src/core/load_balancing/grpclb/grpclb_client_stats.cc

@@ -48,7 +48,7 @@ void GrpcLbClientStats::AddCallDropped(const char* token) {
   gpr_atm_full_fetch_add(&num_calls_started_, (gpr_atm)1);
   gpr_atm_full_fetch_add(&num_calls_finished_, (gpr_atm)1);
   // Record the drop.
-  MutexLock lock(&drop_count_mu_);
+  MutexLock lock(drop_count_mu_);
   if (drop_token_counts_ == nullptr) {
     drop_token_counts_ = std::make_unique<DroppedCallCounts>();
   }
@@ -81,7 +81,7 @@ void GrpcLbClientStats::Get(
                            &num_calls_finished_with_client_failed_to_send_);
   AtomicGetAndResetCounter(num_calls_finished_known_received,
                            &num_calls_finished_known_received_);
-  MutexLock lock(&drop_count_mu_);
+  MutexLock lock(drop_count_mu_);
   *drop_token_counts = std::move(drop_token_counts_);
 }
 

data/src/core/load_balancing/grpclb/load_balancer_api.cc

@@ -26,8 +26,8 @@
 
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/timestamp.upb.h"
+#include "grpc/lb/v1/load_balancer.upb.h"
 #include "src/core/util/memory.h"
-#include "src/proto/grpc/lb/v1/load_balancer.upb.h"
 #include "upb/base/string_view.h"
 #include "absl/log/log.h"
 

data/src/core/load_balancing/grpclb/load_balancer_api.h

@@ -41,7 +41,9 @@ struct GrpcLbServer {
   int32_t ip_size;
   char ip_addr[GRPC_GRPCLB_SERVER_IP_ADDRESS_MAX_SIZE];
   int32_t port;
-  char load_balance_token[GRPC_GRPCLB_SERVER_LOAD_BALANCE_TOKEN_MAX_SIZE];
+  // One extra byte for the trailing NUL: load_balance_token is read as a C
+  // string by the drop path (gpr_strdup/strcmp) and AsText().
+  char load_balance_token[GRPC_GRPCLB_SERVER_LOAD_BALANCE_TOKEN_MAX_SIZE + 1];
   bool drop;
 
   bool operator==(const GrpcLbServer& other) const;

data/src/core/load_balancing/health_check_client.cc

@@ -30,6 +30,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "grpc/health/v1/health.upb.h"
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/subchannel.h"
@@ -52,7 +53,6 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/work_serializer.h"
-#include "src/proto/grpc/health/v1/health.upb.h"
 #include "upb/base/string_view.h"
 #include "upb/mem/arena.hpp"
 #include "absl/log/log.h"
@@ -123,7 +123,7 @@ void HealthProducer::HealthChecker::NotifyWatchersLocked(
       << "HealthProducer " << producer_.get() << " HealthChecker " << this
       << ": reporting state " << ConnectivityStateName(state) << " to watchers";
   work_serializer_->Run([self = Ref(), state, status = std::move(status)]() {
-    MutexLock lock(&self->producer_->mu_);
+    MutexLock lock(self->producer_->mu_);
     for (HealthWatcher* watcher : self->watchers_) {
       watcher->Notify(state, status);
     }
@@ -142,7 +142,7 @@ void HealthProducer::HealthChecker::OnHealthWatchStatusChange(
   }
   work_serializer_->Run(
       [self = Ref(), state, status = std::move(use_status)]() mutable {
-        MutexLock lock(&self->producer_->mu_);
+        MutexLock lock(self->producer_->mu_);
         if (self->stream_client_ != nullptr) {
           self->state_ = state;
           self->status_ = std::move(status);
@@ -313,7 +313,7 @@ void HealthProducer::Orphaned() {
   GRPC_TRACE_LOG(health_check_client, INFO)
       << "HealthProducer " << this << ": shutting down";
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     health_checkers_.clear();
   }
   subchannel_->CancelConnectivityStateWatch(connectivity_watcher_);
@@ -323,7 +323,7 @@ void HealthProducer::Orphaned() {
 void HealthProducer::AddWatcher(
     HealthWatcher* watcher,
     const std::optional<std::string>& health_check_service_name) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   grpc_pollset_set_add_pollset_set(interested_parties_,
                                    watcher->interested_parties());
   if (!health_check_service_name.has_value()) {
@@ -344,7 +344,7 @@ void HealthProducer::AddWatcher(
 void HealthProducer::RemoveWatcher(
     HealthWatcher* watcher,
     const std::optional<std::string>& health_check_service_name) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   grpc_pollset_set_del_pollset_set(interested_parties_,
                                    watcher->interested_parties());
   if (!health_check_service_name.has_value()) {
@@ -363,7 +363,7 @@ void HealthProducer::OnConnectivityStateChange(grpc_connectivity_state state,
       << "HealthProducer " << this
       << ": subchannel state update: state=" << ConnectivityStateName(state)
       << " status=" << status;
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   state_ = state;
   status_ = status;
   for (const auto& [_, health_checker] : health_checkers_) {

data/src/core/load_balancing/lb_policy.cc

@@ -72,7 +72,7 @@ LoadBalancingPolicy::PickResult LoadBalancingPolicy::QueuePicker::Pick(
   // returns, then by the time this function returns, the pick will already
   // have been processed, and we'll be trying to re-process the same pick
   // again, leading to a crash.
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (parent_ != nullptr) {
     auto* parent = parent_.release();  // ref held by lambda.
     ExecCtx::Run(DEBUG_LOCATION,

data/src/core/load_balancing/oob_backend_metric.cc

@@ -215,7 +215,7 @@ void OrcaProducer::Start(WeakRefCountedPtr<Subchannel> subchannel) {
 
 void OrcaProducer::Orphaned() {
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     stream_client_.reset();
   }
   GRPC_CHECK(subchannel_ != nullptr);  // Should not be called before Start().
@@ -224,7 +224,7 @@ void OrcaProducer::Orphaned() {
 }
 
 void OrcaProducer::AddWatcher(OrcaWatcher* watcher) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   watchers_.insert(watcher);
   Duration watcher_interval = watcher->report_interval();
   if (watcher_interval < report_interval_) {
@@ -235,7 +235,7 @@ void OrcaProducer::AddWatcher(OrcaWatcher* watcher) {
 }
 
 void OrcaProducer::RemoveWatcher(OrcaWatcher* watcher) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   watchers_.erase(watcher);
   if (watchers_.empty()) {
     stream_client_.reset();
@@ -270,14 +270,14 @@ void OrcaProducer::NotifyWatchers(
     const BackendMetricData& backend_metric_data) {
   GRPC_TRACE_LOG(orca_client, INFO)
       << "OrcaProducer " << this << ": reporting backend metrics to watchers";
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   for (OrcaWatcher* watcher : watchers_) {
     watcher->watcher()->OnBackendMetricReport(backend_metric_data);
   }
 }
 
 void OrcaProducer::OnConnectivityStateChange(grpc_connectivity_state state) {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   if (state == GRPC_CHANNEL_READY) {
     if (!watchers_.empty()) MaybeStartStreamLocked();
   } else {

data/src/core/load_balancing/outlier_detection/outlier_detection.cc

@@ -240,12 +240,12 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
     }
 
     RefCountedPtr<EndpointState> endpoint_state() {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       return endpoint_state_;
     }
 
     void set_endpoint_state(RefCountedPtr<EndpointState> endpoint_state) {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       endpoint_state_ = std::move(endpoint_state);
     }
 

data/src/core/load_balancing/ring_hash/ring_hash.cc

@@ -105,7 +105,9 @@ class RingHashLbConfig final : public LoadBalancingPolicy::Config {
   absl::string_view name() const override { return kRingHash; }
   size_t min_ring_size() const { return min_ring_size_; }
   size_t max_ring_size() const { return max_ring_size_; }
-  absl::string_view request_hash_header() const { return request_hash_header_; }
+  const RefCountedStringValue& request_hash_header() const {
+    return request_hash_header_;
+  }
 
   static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
     static const auto* loader =
@@ -142,7 +144,7 @@ class RingHashLbConfig final : public LoadBalancingPolicy::Config {
  private:
   uint64_t min_ring_size_ = 1024;
   uint64_t max_ring_size_ = 4096;
-  std::string request_hash_header_;
+  RefCountedStringValue request_hash_header_;
 };
 
 //
@@ -253,34 +255,8 @@ class RingHash final : public LoadBalancingPolicy {
     PickResult Pick(PickArgs args) override;
 
    private:
-    // A fire-and-forget class that schedules endpoint connection attempts
-    // on the control plane WorkSerializer.
-    class EndpointConnectionAttempter final {
-     public:
-      EndpointConnectionAttempter(RefCountedPtr<RingHash> ring_hash,
-                                  RefCountedPtr<RingHashEndpoint> endpoint)
-          : ring_hash_(std::move(ring_hash)), endpoint_(std::move(endpoint)) {
-        // Hop into ExecCtx, so that we're not holding the data plane mutex
-        // while we run control-plane code.
-        GRPC_CLOSURE_INIT(&closure_, RunInExecCtx, this, nullptr);
-        ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
-      }
-
-     private:
-      static void RunInExecCtx(void* arg, grpc_error_handle /*error*/) {
-        auto* self = static_cast<EndpointConnectionAttempter*>(arg);
-        self->ring_hash_->work_serializer()->Run([self]() {
-          if (!self->ring_hash_->shutdown_) {
-            self->endpoint_->RequestConnectionLocked();
-          }
-          delete self;
-        });
-      }
-
-      RefCountedPtr<RingHash> ring_hash_;
-      RefCountedPtr<RingHashEndpoint> endpoint_;
-      grpc_closure closure_;
-    };
+    void RequestConnectionForEndpoint(
+        const RefCountedPtr<RingHashEndpoint>& endpoint);
 
     RefCountedPtr<RingHash> ring_hash_;
     RefCountedPtr<Ring> ring_;
@@ -294,6 +270,8 @@ class RingHash final : public LoadBalancingPolicy {
 
   void ShutdownLocked() override;
 
+  absl::Status LegacyUpdateLocked(UpdateArgs args);
+
   // Updates the aggregate policy's connectivity state based on the
   // number of endpoints in each state, creating a new picker.
   // If the call to this method is triggered by an endpoint entering
@@ -385,9 +363,7 @@ RingHash::PickResult RingHash::Picker::Pick(PickArgs args) {
         case GRPC_CHANNEL_READY:
           return endpoint_info.picker->Pick(args);
         case GRPC_CHANNEL_IDLE:
-          new EndpointConnectionAttempter(
-              ring_hash_.Ref(DEBUG_LOCATION, "EndpointConnectionAttempter"),
-              endpoint_info.endpoint);
+          RequestConnectionForEndpoint(endpoint_info.endpoint);
           [[fallthrough]];
         case GRPC_CHANNEL_CONNECTING:
           return PickResult::Queue();
@@ -406,9 +382,7 @@ RingHash::PickResult RingHash::Picker::Pick(PickArgs args) {
         return endpoint_info.picker->Pick(args);
       }
       if (!requested_connection && endpoint_info.state == GRPC_CHANNEL_IDLE) {
-        new EndpointConnectionAttempter(
-            ring_hash_.Ref(DEBUG_LOCATION, "EndpointConnectionAttempter"),
-            endpoint_info.endpoint);
+        RequestConnectionForEndpoint(endpoint_info.endpoint);
         requested_connection = true;
       }
     }
@@ -423,6 +397,15 @@ RingHash::PickResult RingHash::Picker::Pick(PickArgs args) {
   return PickResult::Fail(absl::UnavailableError(message));
 }
 
+void RingHash::Picker::RequestConnectionForEndpoint(
+    const RefCountedPtr<RingHashEndpoint>& endpoint) {
+  ring_hash_->work_serializer()->Run([ring_hash = ring_hash_, endpoint]() {
+    if (!ring_hash->shutdown_) {
+      endpoint->RequestConnectionLocked();
+    }
+  });
+}
+
 //
 // RingHash::Ring
 //
@@ -684,6 +667,95 @@ void RingHash::ResetBackoffLocked() {
 }
 
 absl::Status RingHash::UpdateLocked(UpdateArgs args) {
+  if (!IsRingHashUpdateCleanupEnabled()) {
+    return LegacyUpdateLocked(std::move(args));
+  }
+  // Save channel args.
+  args_ = std::move(args.args);
+  // Save config.
+  auto* config = DownCast<RingHashLbConfig*>(args.config.get());
+  request_hash_header_ = RefCountedStringValue(config->request_hash_header());
+  // Update resolution note.
+  resolution_note_ = std::move(args.resolution_note);
+  // Update endpoint list.
+  absl::Status status;
+  if (!args.addresses.ok()) {
+    GRPC_TRACE_LOG(ring_hash_lb, INFO)
+        << "[RH " << this << "] received update with addresses error: "
+        << args.addresses.status();
+    status = args.addresses.status();
+    // If we already have an endpoint list, then we keep using it.
+  } else {
+    GRPC_TRACE_LOG(ring_hash_lb, INFO) << "[RH " << this << "] received update";
+    // De-dup endpoints, taking weight into account.
+    endpoints_.clear();
+    std::map<EndpointAddressSet, OrphanablePtr<RingHashEndpoint>> endpoint_map;
+    std::vector<std::string> errors;
+    (*args.addresses)->ForEach([&](const EndpointAddresses& endpoint) {
+      const EndpointAddressSet key(endpoint.addresses());
+      auto& rh_endpoint = endpoint_map[key];
+      // If we've already seen this key, combine weights and skip the dup.
+      // Note: We will already have created or updated the RingHashEndpoint
+      // object when we saw the first endpoint with this key.  However,
+      // nothing inside of RingHashEndpoint uses the weight, so that's okay.
+      if (rh_endpoint != nullptr) {
+        EndpointAddresses& prev_endpoint = endpoints_[rh_endpoint->index()];
+        int weight_arg =
+            endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
+        int prev_weight_arg =
+            prev_endpoint.args().GetInt(GRPC_ARG_ADDRESS_WEIGHT).value_or(1);
+        GRPC_TRACE_LOG(ring_hash_lb, INFO)
+            << "[RH " << this << "] merging duplicate endpoint for "
+            << key.ToString() << ", combined weight "
+            << weight_arg + prev_weight_arg;
+        prev_endpoint = EndpointAddresses(
+            prev_endpoint.addresses(),
+            prev_endpoint.args().Set(GRPC_ARG_ADDRESS_WEIGHT,
+                                     weight_arg + prev_weight_arg));
+        return;
+      }
+      // Have not yet seen this key, so add a new endpoint.
+      const size_t index = endpoints_.size();
+      endpoints_.push_back(endpoint);
+      // If present in old map, retain it; otherwise, create a new one.
+      auto it = endpoint_map_.find(key);
+      if (it != endpoint_map_.end()) {
+        absl::Status status = it->second->UpdateLocked(index);
+        if (!status.ok()) {
+          errors.emplace_back(absl::StrCat("endpoint ", key.ToString(), ": ",
+                                           status.ToString()));
+        }
+        rh_endpoint = std::move(it->second);
+      } else {
+        rh_endpoint =
+            MakeOrphanable<RingHashEndpoint>(RefAsSubclass<RingHash>(), index);
+      }
+    });
+    endpoint_map_ = std::move(endpoint_map);
+    if (!errors.empty()) {
+      status = absl::UnavailableError(absl::StrCat(
+          "errors from children: [", absl::StrJoin(errors, "; "), "]"));
+    }
+  }
+  // If the address list is empty, report TRANSIENT_FAILURE.
+  if (endpoints_.empty()) {
+    if (status.ok()) {
+      status = absl::UnavailableError(
+          absl::StrCat("empty address list: ", resolution_note_));
+    }
+    channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_TRANSIENT_FAILURE, status,
+        MakeRefCounted<TransientFailurePicker>(status));
+  } else {
+    // Build new ring.
+    ring_ = MakeRefCounted<Ring>(this, config);
+    // Return a new picker.
+    UpdateAggregatedConnectivityStateLocked(absl::OkStatus());
+  }
+  return status;
+}
+
+absl::Status RingHash::LegacyUpdateLocked(UpdateArgs args) {
   // Check address list.
   if (args.addresses.ok()) {
     GRPC_TRACE_LOG(ring_hash_lb, INFO) << "[RH " << this << "] received update";
@@ -724,7 +796,7 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
   args_ = std::move(args.args);
   // Save config.
   auto* config = DownCast<RingHashLbConfig*>(args.config.get());
-  request_hash_header_ = RefCountedStringValue(config->request_hash_header());
+  request_hash_header_ = config->request_hash_header();
   // Build new ring.
   ring_ = MakeRefCounted<Ring>(this, config);
   // Update endpoint map.

data/src/core/load_balancing/rls/rls.cc

@@ -51,6 +51,7 @@
 #include <utility>
 #include <vector>
 
+#include "grpc/lookup/v1/rls.upb.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/credentials/transport/fake/fake_credentials.h"
@@ -97,7 +98,6 @@
 #include "src/core/util/uuid_v4.h"
 #include "src/core/util/validation_errors.h"
 #include "src/core/util/work_serializer.h"
-#include "src/proto/grpc/lookup/v1/rls.upb.h"
 #include "upb/base/string_view.h"
 #include "upb/mem/arena.hpp"
 #include "absl/base/thread_annotations.h"
@@ -872,7 +872,7 @@ void RlsLb::ChildPolicyWrapper::ChildPolicyHelper::UpdateState(
       << ", status=" << status << ", picker=" << picker.get() << ")";
   if (wrapper_->is_shutdown_) return;
   {
-    MutexLock lock(&wrapper_->lb_policy_->mu_);
+    MutexLock lock(wrapper_->lb_policy_->mu_);
     // TODO(roth): It looks like this ignores subsequent TF updates that
     // might change the status used to fail picks, which seems wrong.
     if (wrapper_->connectivity_state_ == GRPC_CHANNEL_TRANSIENT_FAILURE &&
@@ -973,7 +973,7 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
       << "[rlslb " << lb_policy_.get() << "] picker=" << this
       << ": request keys: " << key.ToString();
   Timestamp now = Timestamp::Now();
-  MutexLock lock(&lb_policy_->mu_);
+  MutexLock lock(lb_policy_->mu_);
   if (lb_policy_->is_shutdown_) {
     return PickResult::Fail(
         absl::UnavailableError("LB policy already shut down"));
@@ -1090,7 +1090,7 @@ void RlsLb::Cache::Entry::BackoffTimer::Orphan() {
 
 void RlsLb::Cache::Entry::BackoffTimer::OnBackoffTimerLocked() {
   {
-    MutexLock lock(&entry_->lb_policy_->mu_);
+    MutexLock lock(entry_->lb_policy_->mu_);
     GRPC_TRACE_LOG(rls_lb, INFO)
         << "[rlslb " << entry_->lb_policy_.get()
         << "] cache entry=" << entry_.get() << " "
@@ -1418,7 +1418,7 @@ void RlsLb::Cache::OnCleanupTimer() {
       << "[rlslb " << lb_policy_ << "] cache cleanup timer fired";
   std::vector<RefCountedPtr<ChildPolicyWrapper>>
       child_policy_wrappers_to_delete;
-  MutexLock lock(&lb_policy_->mu_);
+  MutexLock lock(lb_policy_->mu_);
   if (!cleanup_timer_handle_.has_value()) return;
   if (lb_policy_->is_shutdown_) return;
   for (auto it = map_.begin(); it != map_.end();) {
@@ -1473,7 +1473,7 @@ void RlsLb::RlsChannel::StateWatcher::OnConnectivityStateChange(
       << " StateWatcher=" << this << ": state changed to "
       << ConnectivityStateName(new_state) << " (" << status << ")";
   if (rls_channel_->is_shutdown_) return;
-  MutexLock lock(&lb_policy->mu_);
+  MutexLock lock(lb_policy->mu_);
   if (new_state == GRPC_CHANNEL_READY && was_transient_failure_) {
     was_transient_failure_ = false;
     // Reset the backoff of all cache entries, so that we don't
@@ -1540,9 +1540,15 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
       lb_policy_->channel_control_helper()->GetUnsafeChannelCredentials();
   // Use the parent channel's authority.
   auto authority = lb_policy_->channel_control_helper()->GetAuthority();
-  ChannelArgs args = ChannelArgs()
-                         .Set(GRPC_ARG_DEFAULT_AUTHORITY, authority)
-                         .Set(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, 1);
+  ChannelArgs args;
+  const grpc_channel_args* child_args =
+      lb_policy_->channel_args_.GetPointer<grpc_channel_args>(
+          GRPC_ARG_CHILD_CHANNEL_ARGS);
+  if (child_args != nullptr) {
+    args = ChannelArgs::FromC(child_args).UnionWith(args);
+  }
+  args = args.Set(GRPC_ARG_DEFAULT_AUTHORITY, authority)
+             .Set(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, 1);
   // Propagate fake security connector expected targets, if any.
   // (This is ugly, but it seems better than propagating all channel args
   // from the parent channel by default and then having a giant
@@ -1685,7 +1691,7 @@ void RlsLb::RlsRequest::StartCall(void* arg, grpc_error_handle /*error*/) {
 
 void RlsLb::RlsRequest::StartCallLocked() {
   {
-    MutexLock lock(&lb_policy_->mu_);
+    MutexLock lock(lb_policy_->mu_);
     if (lb_policy_->is_shutdown_) return;
   }
   Timestamp now = Timestamp::Now();
@@ -1775,7 +1781,7 @@ void RlsLb::RlsRequest::OnRlsCallCompleteLocked(grpc_error_handle error) {
       child_policy_wrappers_to_delete;
   OrphanablePtr<ChildPolicyHandler> child_policy_to_delete;
   {
-    MutexLock lock(&lb_policy_->mu_);
+    MutexLock lock(lb_policy_->mu_);
     if (lb_policy_->is_shutdown_) return;
     rls_channel_->ReportResponseLocked(response.status.ok());
     Cache::Entry* cache_entry =
@@ -1963,7 +1969,7 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
       child_policy_wrappers_to_delete;
   OrphanablePtr<ChildPolicyHandler> child_policy_to_delete;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     // Swap out RLS channel if needed.
     if (old_config == nullptr ||
         config_->lookup_service() != old_config->lookup_service()) {
@@ -2020,7 +2026,7 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
     registered_metric_callback_ =
         channel_control_helper()->GetStatsPluginGroup().RegisterCallback(
             [this](CallbackMetricReporter& reporter) {
-              MutexLock lock(&mu_);
+              MutexLock lock(mu_);
               cache_.ReportMetricsLocked(reporter);
             },
             Duration::Seconds(5), kMetricCacheSize, kMetricCacheEntries);
@@ -2041,7 +2047,7 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
 }
 
 void RlsLb::ExitIdleLocked() {
-  MutexLock lock(&mu_);
+  MutexLock lock(mu_);
   for (auto& [_, child] : child_policy_map_) {
     child->ExitIdleLocked();
   }
@@ -2049,7 +2055,7 @@ void RlsLb::ExitIdleLocked() {
 
 void RlsLb::ResetBackoffLocked() {
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     rls_channel_->ResetBackoff();
     cache_.ResetAllBackoff();
   }
@@ -2066,7 +2072,7 @@ void RlsLb::ShutdownLocked() {
       child_policy_wrappers_to_delete;
   OrphanablePtr<RlsChannel> rls_channel_to_delete;
   {
-    MutexLock lock(&mu_);
+    MutexLock lock(mu_);
     is_shutdown_ = true;
     config_.reset(DEBUG_LOCATION, "ShutdownLocked");
     child_policy_wrappers_to_delete = cache_.Shutdown();
@@ -2099,7 +2105,7 @@ void RlsLb::UpdatePickerLocked() {
     int num_idle = 0;
     int num_connecting = 0;
     {
-      MutexLock lock(&mu_);
+      MutexLock lock(mu_);
       if (is_shutdown_) return;
       for (auto& [_, child] : child_policy_map_) {
         grpc_connectivity_state child_state = child->connectivity_state();