grpc 1.71.0 → 1.73.0

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

@@ -65,13 +65,13 @@
 #include "src/core/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/credentials/transport/fake/fake_credentials.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/security/credentials/fake/fake_credentials.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call.h"
@@ -97,6 +97,7 @@
 #include "src/core/util/match.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
@@ -401,7 +402,8 @@ class RlsLb final : public LoadBalancingPolicy {
       size_t Size() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_);
 
       // Pick subchannel for request based on the entry's state.
-      PickResult Pick(PickArgs args) ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_);
+      PickResult Pick(PickArgs args, absl::string_view lookup_service)
+          ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_);
 
       // If the cache entry is in backoff state, resets the backoff and, if
       // applicable, its backoff timer. The method does not update the LB
@@ -684,17 +686,16 @@ class RlsLb final : public LoadBalancingPolicy {
 
   void ShutdownLocked() override;
 
-  // Returns a new picker to the channel to trigger reprocessing of
-  // pending picks.  Schedules the actual picker update on the ExecCtx
-  // to be run later, so it's safe to invoke this while holding the lock.
+  // Schedules a call to UpdatePickerLocked() on the WorkSerializer.
+  // The call will be run asynchronously, so it's safe to invoke this
+  // while holding the lock.
   void UpdatePickerAsync();
-  // Hops into work serializer and calls UpdatePickerLocked().
-  static void UpdatePickerCallback(void* arg, grpc_error_handle error);
   // Updates the picker in the work serializer.
   void UpdatePickerLocked() ABSL_LOCKS_EXCLUDED(&mu_);
 
   template <typename HandleType>
   void MaybeExportPickCount(HandleType handle, absl::string_view target,
+                            absl::string_view lookup_service,
                             const PickResult& pick_result);
 
   const std::string instance_uuid_;
@@ -1002,7 +1003,7 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
       GRPC_TRACE_LOG(rls_lb, INFO)
           << "[rlslb " << lb_policy_.get() << "] picker=" << this
           << ": using cache entry " << entry;
-      return entry->Pick(args);
+      return entry->Pick(args, config_->lookup_service());
     }
     // If the entry is in backoff, then use the default target if set,
     // or else fail the pick.
@@ -1028,7 +1029,8 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::PickFromDefaultTargetOrFail(
         << reason << "; using default target";
     auto pick_result = default_child_policy_->Pick(args);
     lb_policy_->MaybeExportPickCount(kMetricDefaultTargetPicks,
-                                     config_->default_target(), pick_result);
+                                     config_->default_target(),
+                                     config_->lookup_service(), pick_result);
     return pick_result;
   }
   GRPC_TRACE_LOG(rls_lb, INFO)
@@ -1139,7 +1141,8 @@ size_t RlsLb::Cache::Entry::Size() const {
   return lb_policy_->cache_.EntrySizeForKey(*lru_iterator_);
 }
 
-LoadBalancingPolicy::PickResult RlsLb::Cache::Entry::Pick(PickArgs args) {
+LoadBalancingPolicy::PickResult RlsLb::Cache::Entry::Pick(
+    PickArgs args, absl::string_view lookup_service) {
   size_t i = 0;
   ChildPolicyWrapper* child_policy_wrapper = nullptr;
   // Skip targets before the last one that are in state TRANSIENT_FAILURE.
@@ -1169,7 +1172,8 @@ LoadBalancingPolicy::PickResult RlsLb::Cache::Entry::Pick(PickArgs args) {
       << "; delegating";
   auto pick_result = child_policy_wrapper->Pick(args);
   lb_policy_->MaybeExportPickCount(kMetricTargetPicks,
-                                   child_policy_wrapper->target(), pick_result);
+                                   child_policy_wrapper->target(),
+                                   lookup_service, pick_result);
   // Add header data.
   if (!header_data_.empty()) {
     auto* complete_pick =
@@ -1554,7 +1558,7 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
     auto parent_channelz_node =
         lb_policy_->channel_args_.GetObjectRef<channelz::ChannelNode>();
     if (child_channelz_node != nullptr && parent_channelz_node != nullptr) {
-      parent_channelz_node->AddChildChannel(child_channelz_node->uuid());
+      child_channelz_node->AddParent(parent_channelz_node.get());
       parent_channelz_node_ = std::move(parent_channelz_node);
     }
     // Start connectivity watch.
@@ -1575,7 +1579,7 @@ void RlsLb::RlsChannel::Orphan() {
     if (parent_channelz_node_ != nullptr) {
       channelz::ChannelNode* child_channelz_node = channel_->channelz_node();
       CHECK_NE(child_channelz_node, nullptr);
-      parent_channelz_node_->RemoveChildChannel(child_channelz_node->uuid());
+      child_channelz_node->RemoveParent(parent_channelz_node_.get());
     }
     // Stop connectivity watch.
     if (watcher_ != nullptr) {
@@ -1849,9 +1853,9 @@ RlsLb::ResponseInfo RlsLb::RlsRequest::ParseResponseProto() {
 
 std::string GenerateUUID() {
   absl::uniform_int_distribution<uint64_t> distribution;
-  absl::BitGen bitgen;
-  uint64_t hi = distribution(bitgen);
-  uint64_t lo = distribution(bitgen);
+  SharedBitGen g;
+  uint64_t hi = distribution(g);
+  uint64_t lo = distribution(g);
   return GenerateUUIDv4(hi, lo);
 }
 
@@ -2057,23 +2061,10 @@ void RlsLb::ShutdownLocked() {
 }
 
 void RlsLb::UpdatePickerAsync() {
-  // Run via the ExecCtx, since the caller may be holding the lock, and
-  // we don't want to be doing that when we hop into the WorkSerializer,
-  // in case the WorkSerializer callback happens to run inline.
-  ExecCtx::Run(
-      DEBUG_LOCATION,
-      GRPC_CLOSURE_CREATE(UpdatePickerCallback,
-                          Ref(DEBUG_LOCATION, "UpdatePickerCallback").release(),
-                          grpc_schedule_on_exec_ctx),
-      absl::OkStatus());
-}
-
-void RlsLb::UpdatePickerCallback(void* arg, grpc_error_handle /*error*/) {
-  auto* rls_lb = static_cast<RlsLb*>(arg);
-  rls_lb->work_serializer()->Run([rls_lb]() {
-    RefCountedPtr<RlsLb> lb_policy(rls_lb);
-    lb_policy->UpdatePickerLocked();
-    lb_policy.reset(DEBUG_LOCATION, "UpdatePickerCallback");
+  work_serializer()->Run([self = RefAsSubclass<RlsLb>(
+                              DEBUG_LOCATION, "UpdatePickerAsync")]() mutable {
+    self->UpdatePickerLocked();
+    self.reset(DEBUG_LOCATION, "UpdatePickerAsync");
   });
 }
 
@@ -2129,6 +2120,7 @@ void RlsLb::UpdatePickerLocked() {
 
 template <typename HandleType>
 void RlsLb::MaybeExportPickCount(HandleType handle, absl::string_view target,
+                                 absl::string_view lookup_service,
                                  const PickResult& pick_result) {
   absl::string_view pick_result_string = Match(
       pick_result.result,
@@ -2140,11 +2132,10 @@ void RlsLb::MaybeExportPickCount(HandleType handle, absl::string_view target,
       [](const LoadBalancingPolicy::PickResult::Drop&) { return "drop"; });
   if (pick_result_string.empty()) return;  // Don't report queued picks.
   auto& stats_plugins = channel_control_helper()->GetStatsPluginGroup();
-  stats_plugins.AddCounter(
-      handle, 1,
-      {channel_control_helper()->GetTarget(), config_->lookup_service(), target,
-       pick_result_string},
-      {});
+  stats_plugins.AddCounter(handle, 1,
+                           {channel_control_helper()->GetTarget(),
+                            lookup_service, target, pick_result_string},
+                           {});
 }
 
 //
@@ -2373,14 +2364,18 @@ void RlsLbConfig::RouteLookupConfig::JsonPostLoad(const Json& json,
       errors->AddError("must be valid gRPC target URI");
     }
   }
-  // Clamp maxAge to the max allowed value.
-  if (max_age > kMaxMaxAge) max_age = kMaxMaxAge;
   // If staleAge is set, then maxAge must also be set.
-  if (json.object().find("staleAge") != json.object().end() &&
-      json.object().find("maxAge") == json.object().end()) {
+  const bool stale_age_set =
+      json.object().find("staleAge") != json.object().end();
+  const bool max_age_set = json.object().find("maxAge") != json.object().end();
+  if (stale_age_set && !max_age_set) {
     ValidationErrors::ScopedField field(errors, ".maxAge");
     errors->AddError("must be set if staleAge is set");
   }
+  // Clamp staleAge to the max allowed value.
+  if (stale_age > kMaxMaxAge) stale_age = kMaxMaxAge;
+  // If staleAge is not set, clamp maxAge to the max allowed value.
+  if (!stale_age_set && max_age > kMaxMaxAge) max_age = kMaxMaxAge;
   // Ignore staleAge if greater than or equal to maxAge.
   if (stale_age >= max_age) stale_age = max_age;
   // Validate cacheSizeBytes.

data/src/core/load_balancing/round_robin/round_robin.cc

@@ -47,6 +47,7 @@
 #include "src/core/util/json/json.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/work_serializer.h"
 
 namespace grpc_core {
@@ -166,8 +167,6 @@ class RoundRobin final : public LoadBalancingPolicy {
   OrphanablePtr<RoundRobinEndpointList> latest_pending_endpoint_list_;
 
   bool shutdown_ = false;
-
-  absl::BitGen bit_gen_;
 };
 
 //
@@ -180,7 +179,7 @@ RoundRobin::Picker::Picker(
     : parent_(parent), pickers_(std::move(pickers)) {
   // For discussion on why we generate a random starting index for
   // the picker, see https://github.com/grpc/grpc-go/issues/2580.
-  size_t index = absl::Uniform<size_t>(parent->bit_gen_, 0, pickers_.size());
+  size_t index = absl::Uniform<size_t>(SharedBitGen(), 0, pickers_.size());
   last_picked_index_.store(index, std::memory_order_relaxed);
   GRPC_TRACE_LOG(round_robin, INFO)
       << "[RR " << parent_ << " picker " << this

data/src/core/load_balancing/weighted_round_robin/weighted_round_robin.cc

@@ -68,6 +68,7 @@
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
@@ -415,10 +416,9 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
 
   bool shutdown_ = false;
 
-  absl::BitGen bit_gen_;
-
   // Accessed by picker.
-  std::atomic<uint32_t> scheduler_state_{absl::Uniform<uint32_t>(bit_gen_)};
+  std::atomic<uint32_t> scheduler_state_{
+      absl::Uniform<uint32_t>(SharedBitGen())};
 };
 
 //
@@ -539,7 +539,7 @@ WeightedRoundRobin::Picker::Picker(RefCountedPtr<WeightedRoundRobin> wrr,
                                    WrrEndpointList* endpoint_list)
     : wrr_(std::move(wrr)),
       config_(wrr_->config_),
-      last_picked_index_(absl::Uniform<size_t>(wrr_->bit_gen_)) {
+      last_picked_index_(absl::Uniform<size_t>(SharedBitGen())) {
   for (auto& endpoint : endpoint_list->endpoints()) {
     auto* ep = static_cast<WrrEndpointList::WrrEndpoint*>(endpoint.get());
     if (ep->connectivity_state() == GRPC_CHANNEL_READY) {

data/src/core/load_balancing/weighted_target/weighted_target.cc

@@ -59,6 +59,7 @@
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
@@ -139,11 +140,6 @@ class WeightedTargetLb final : public LoadBalancingPolicy {
 
    private:
     PickerList pickers_;
-
-    // TODO(roth): Consider using a separate thread-local BitGen for each CPU
-    // to avoid the need for this mutex.
-    Mutex mu_;
-    absl::BitGen bit_gen_ ABSL_GUARDED_BY(&mu_);
   };
 
   // Each WeightedChild holds a ref to its parent WeightedTargetLb.
@@ -250,10 +246,8 @@ class WeightedTargetLb final : public LoadBalancingPolicy {
 WeightedTargetLb::PickResult WeightedTargetLb::WeightedPicker::Pick(
     PickArgs args) {
   // Generate a random number in [0, total weight).
-  const uint64_t key = [&]() {
-    MutexLock lock(&mu_);
-    return absl::Uniform<uint64_t>(bit_gen_, 0, pickers_.back().first);
-  }();
+  const uint64_t key =
+      absl::Uniform<uint64_t>(SharedBitGen(), 0, pickers_.back().first);
   // Find the index in pickers_ corresponding to key.
   size_t mid = 0;
   size_t start_index = 0;
@@ -350,7 +344,7 @@ absl::Status WeightedTargetLb::UpdateLocked(UpdateArgs args) {
   update_in_progress_ = false;
   if (config_->target_map().empty()) {
     absl::Status status = absl::UnavailableError(absl::StrCat(
-        "no children in weighted_target policy: ", args.resolution_note));
+        "no children in weighted_target policy (", args.resolution_note, ")"));
     channel_control_helper()->UpdateState(
         GRPC_CHANNEL_TRANSIENT_FAILURE, status,
         MakeRefCounted<TransientFailurePicker>(status));

data/src/core/load_balancing/xds/cds.cc

@@ -542,16 +542,9 @@ Json CdsLb::CreateChildPolicyConfigForLeafCluster(
           cluster_resource.type);
   // Determine what xDS LB policy to use.
   Json xds_lb_policy;
-  if (is_logical_dns) {
-    xds_lb_policy = Json::FromArray({
-        Json::FromObject({
-            {"pick_first", Json::FromObject({})},
-        }),
-    });
-  }
-  // TODO(roth): Remove this "else if" block after the 1.63 release.
-  else if (XdsAggregateClusterBackwardCompatibilityEnabled() &&
-           aggregate_cluster_resource != nullptr) {
+  // TODO(roth): Remove this "if" condition after the 1.63 release.
+  if (XdsAggregateClusterBackwardCompatibilityEnabled() &&
+      aggregate_cluster_resource != nullptr) {
     xds_lb_policy =
         Json::FromArray(aggregate_cluster_resource->lb_policy_config);
   } else {

data/src/core/load_balancing/xds/xds_cluster_impl.cc

@@ -37,11 +37,11 @@
 #include "absl/strings/string_view.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/credentials/transport/xds/xds_credentials.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolved_address.h"
-#include "src/core/lib/security/credentials/xds/xds_credentials.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/load_balancing/backend_metric_data.h"
 #include "src/core/load_balancing/child_policy_handler.h"

data/src/core/load_balancing/xds/xds_override_host.cc

@@ -286,6 +286,15 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
       address_list_ = std::move(address_list);
     }
 
+    const ChannelArgs& per_endpoint_args() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      return per_endpoint_args_;
+    }
+    void set_per_endpoint_args(ChannelArgs per_endpoint_args)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      per_endpoint_args_ = std::move(per_endpoint_args);
+    }
+
     Timestamp last_used_time() const
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
       return last_used_time_;
@@ -304,6 +313,7 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
         &XdsOverrideHostLb::mu_) = XdsHealthStatus(XdsHealthStatus::kUnknown);
     RefCountedStringValue address_list_
         ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_);
+    ChannelArgs per_endpoint_args_ ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_);
     Timestamp last_used_time_ ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_) =
         Timestamp::InfPast();
   };
@@ -319,30 +329,6 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
     PickResult Pick(PickArgs args) override;
 
    private:
-    class SubchannelConnectionRequester final {
-     public:
-      explicit SubchannelConnectionRequester(
-          RefCountedPtr<SubchannelWrapper> subchannel)
-          : subchannel_(std::move(subchannel)) {
-        GRPC_CLOSURE_INIT(&closure_, RunInExecCtx, this, nullptr);
-        // Hop into ExecCtx, so that we don't get stuck running
-        // arbitrary WorkSerializer callbacks while doing a pick.
-        ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
-      }
-
-     private:
-      static void RunInExecCtx(void* arg, grpc_error_handle /*error*/) {
-        auto* self = static_cast<SubchannelConnectionRequester*>(arg);
-        self->subchannel_->policy()->work_serializer()->Run([self]() {
-          self->subchannel_->RequestConnection();
-          delete self;
-        });
-      }
-
-      RefCountedPtr<SubchannelWrapper> subchannel_;
-      grpc_closure closure_;
-    };
-
     std::optional<LoadBalancingPolicy::PickResult> PickOverriddenHost(
         XdsOverrideHostAttribute* override_host_attr) const;
 
@@ -493,7 +479,10 @@ XdsOverrideHostLb::Picker::PickOverriddenHost(
     GRPC_TRACE_LOG(xds_override_host_lb, INFO)
         << "Picker override found IDLE subchannel";
     // Deletes itself after the connection is requested.
-    new SubchannelConnectionRequester(std::move(idle_subchannel));
+    policy_->work_serializer()->Run(
+        [subchannel = std::move(idle_subchannel)]() {
+          subchannel->RequestConnection();
+        });
     return PickResult::Queue();
   }
   // No READY or IDLE subchannels.  If we found a CONNECTING subchannel,
@@ -793,8 +782,12 @@ void XdsOverrideHostLb::UpdateAddressMap(
   struct AddressInfo {
     XdsHealthStatus eds_health_status;
     RefCountedStringValue address_list;
-    AddressInfo(XdsHealthStatus status, RefCountedStringValue addresses)
-        : eds_health_status(status), address_list(std::move(addresses)) {}
+    ChannelArgs per_endpoint_args;
+    AddressInfo(XdsHealthStatus status, RefCountedStringValue addresses,
+                ChannelArgs args)
+        : eds_health_status(status),
+          address_list(std::move(addresses)),
+          per_endpoint_args(std::move(args)) {}
   };
   std::map<const std::string, AddressInfo> addresses_for_map;
   endpoints.ForEach([&](const EndpointAddresses& endpoint) {
@@ -830,7 +823,8 @@ void XdsOverrideHostLb::UpdateAddressMap(
                        (end.empty() ? "" : ","), end));
       addresses_for_map.emplace(
           std::piecewise_construct, std::forward_as_tuple(addresses[i]),
-          std::forward_as_tuple(status, std::move(address_list)));
+          std::forward_as_tuple(status, std::move(address_list),
+                                endpoint.args()));
     }
   });
   // Now grab the lock and update subchannel_map_ from addresses_for_map.
@@ -865,9 +859,12 @@ void XdsOverrideHostLb::UpdateAddressMap(
           << "[xds_override_host_lb " << this << "] map key " << address
           << ": setting "
           << "eds_health_status=" << address_info.eds_health_status.ToString()
-          << " address_list=" << address_info.address_list.c_str();
+          << " address_list=" << address_info.address_list.c_str()
+          << " per_endpoint_args=" << address_info.per_endpoint_args.ToString();
       it->second->set_eds_health_status(address_info.eds_health_status);
       it->second->set_address_list(std::move(address_info.address_list));
+      it->second->set_per_endpoint_args(
+          std::move(address_info.per_endpoint_args));
       // Check the entry's last_used_time to determine the next time at
       // which the timer needs to run.
       if (it->second->last_used_time() > idle_threshold) {
@@ -908,14 +905,38 @@ void XdsOverrideHostLb::CreateSubchannelForAddress(absl::string_view address) {
       << address;
   auto addr = StringToSockaddr(address);
   CHECK(addr.ok());
-  // Note: We don't currently have any cases where per_address_args need to
-  // be passed through.  If we encounter any such cases in the future, we
-  // will need to change this to store those attributes from the resolver
-  // update in the map entry.
+  // We need to do 3 things here:
+  // 1. Get the per-endpoint args from the entry in subchannel_map_.
+  // 2. Create the subchannel using those per-endpoint args.
+  // 3. Wrap the subchannel and store the wrapper in subchannel_map_.
+  //
+  // Steps 1 and 3 require holding the lock, but we don't want to hold
+  // the lock in step 2, since we're calling into arbitrary code in the
+  // channel.  Unfortunately, this means we need to grab and release the
+  // lock twice -- and each time, we need to check if some other thread
+  // has preempted us.
+  //
+  // Step 1.
+  ChannelArgs per_endpoint_args;
+  {
+    MutexLock lock(&mu_);
+    auto it = subchannel_map_.find(address);
+    // This can happen if the map entry was removed between the time that
+    // the picker requested the subchannel creation and the time that we got
+    // here.  In that case, we can just make it a no-op, since the update
+    // that removed the entry will have generated a new picker already.
+    if (it == subchannel_map_.end()) return;
+    // This can happen if the picker requests subchannel creation for
+    // the same address multiple times.
+    if (it->second->HasOwnedSubchannel()) return;
+    per_endpoint_args = it->second->per_endpoint_args();
+  }
+  // Step 2.
   auto subchannel = channel_control_helper()->CreateSubchannel(
-      *addr, /*per_address_args=*/ChannelArgs(), args_);
+      *addr, per_endpoint_args, args_);
   auto wrapper = MakeRefCounted<SubchannelWrapper>(
       std::move(subchannel), RefAsSubclass<XdsOverrideHostLb>());
+  // Step 3.
   {
     MutexLock lock(&mu_);
     auto it = subchannel_map_.find(address);

data/src/core/plugin_registry/grpc_plugin_registry.cc

@@ -62,6 +62,7 @@ extern void RegisterOutlierDetectionLbPolicy(
     CoreConfiguration::Builder* builder);
 extern void RegisterWeightedTargetLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterPickFirstLbPolicy(CoreConfiguration::Builder* builder);
+extern void RegisterRingHashLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterRoundRobinLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterWeightedRoundRobinLbPolicy(
     CoreConfiguration::Builder* builder);
@@ -69,6 +70,7 @@ extern void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder);
 extern void RegisterConnectedChannel(CoreConfiguration::Builder* builder);
 extern void RegisterLoadBalancedCallDestination(
     CoreConfiguration::Builder* builder);
+extern void RegisterChttp2Transport(CoreConfiguration::Builder* builder);
 #ifndef GRPC_NO_RLS
 extern void RegisterRlsLbPolicy(CoreConfiguration::Builder* builder);
 #endif  // !GRPC_NO_RLS
@@ -97,11 +99,13 @@ void BuildCoreConfiguration(CoreConfiguration::Builder* builder) {
   RegisterEndpointInfoHandshaker(builder);
   RegisterHttpConnectHandshaker(builder);
   RegisterTCPConnectHandshaker(builder);
+  RegisterChttp2Transport(builder);
   RegisterPriorityLbPolicy(builder);
   RegisterOutlierDetectionLbPolicy(builder);
   RegisterWeightedTargetLbPolicy(builder);
   RegisterPickFirstLbPolicy(builder);
   RegisterRoundRobinLbPolicy(builder);
+  RegisterRingHashLbPolicy(builder);
   RegisterWeightedRoundRobinLbPolicy(builder);
   BuildClientChannelConfiguration(builder);
   SecurityRegisterHandshakerFactories(builder);

data/src/core/plugin_registry/grpc_plugin_registry_extra.cc

@@ -37,7 +37,6 @@ extern void RegisterCdsLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterXdsOverrideHostLbPolicy(
     CoreConfiguration::Builder* builder);
 extern void RegisterXdsWrrLocalityLbPolicy(CoreConfiguration::Builder* builder);
-extern void RegisterRingHashLbPolicy(CoreConfiguration::Builder* builder);
 extern void RegisterFileWatcherCertificateProvider(
     CoreConfiguration::Builder* builder);
 extern void RegisterXdsHttpProxyMapper(CoreConfiguration::Builder* builder);
@@ -60,7 +59,6 @@ void RegisterExtraFilters(CoreConfiguration::Builder* builder) {
   RegisterCdsLbPolicy(builder);
   RegisterXdsOverrideHostLbPolicy(builder);
   RegisterXdsWrrLocalityLbPolicy(builder);
-  RegisterRingHashLbPolicy(builder);
   RegisterFileWatcherCertificateProvider(builder);
   RegisterXdsHttpProxyMapper(builder);
 #endif

data/src/core/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -330,11 +330,9 @@ AresClientChannelDNSResolver::AresRequestWrapper::OnResolvedLocked(
     GRPC_TRACE_VLOG(cares_resolver, 2)
         << "(c-ares resolver) resolver:" << this
         << " dns resolution failed: " << StatusToString(error);
-    std::string error_message;
-    grpc_error_get_str(error, StatusStrProperty::kDescription, &error_message);
     absl::Status status = absl::UnavailableError(
         absl::StrCat("DNS resolution failed for ", resolver_->name_to_resolve(),
-                     ": ", error_message));
+                     ": ", error.message()));
     result.addresses = status;
     result.service_config = status;
   }

data/src/core/resolver/dns/c_ares/grpc_ares_wrapper.h

@@ -34,6 +34,8 @@
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/util/sync.h"
 
+#if GRPC_ARES == 1
+
 #define GRPC_DNS_ARES_DEFAULT_QUERY_TIMEOUT_MS 120000
 
 typedef struct grpc_ares_ev_driver grpc_ares_ev_driver;
@@ -122,4 +124,6 @@ extern void (*grpc_ares_test_only_inject_config)(ares_channel* channel);
 // Exposed in this header for C-core tests only
 extern bool g_grpc_ares_test_only_force_tcp;
 
+#endif
+
 #endif  // GRPC_SRC_CORE_RESOLVER_DNS_C_ARES_GRPC_ARES_WRAPPER_H

data/src/core/resolver/google_c2p/google_c2p_resolver.cc

@@ -32,10 +32,10 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "src/core/config/core_configuration.h"
+#include "src/core/credentials/transport/alts/check_gcp_environment.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
-#include "src/core/lib/security/credentials/alts/check_gcp_environment.h"
 #include "src/core/resolver/resolver.h"
 #include "src/core/resolver/resolver_factory.h"
 #include "src/core/resolver/resolver_registry.h"

data/src/core/resolver/sockaddr/sockaddr_resolver.cc

@@ -86,7 +86,8 @@ bool ParseUri(const URI& uri,
       // Skip targets which are empty.
       continue;
     }
-    auto ith_uri = URI::Create(uri.scheme(), "", std::string(ith_path), {}, "");
+    auto ith_uri = URI::Create(uri.scheme(), /*user_info=*/"", /*host_port=*/"",
+                               std::string(ith_path), {}, "");
     grpc_resolved_address addr;
     if (!ith_uri.ok() || !parse(*ith_uri, &addr)) {
       errors_found = true;

data/src/core/resolver/xds/xds_dependency_manager.cc

@@ -605,11 +605,16 @@ void XdsDependencyManager::PopulateDnsUpdate(const std::string& dns_name,
   locality.name = MakeRefCounted<XdsLocalityName>("", "", "");
   locality.lb_weight = 1;
   if (result.addresses.ok()) {
+    std::vector<grpc_resolved_address> addresses;
+    ChannelArgs address_args = result.addresses->front().args();
     for (const auto& address : *result.addresses) {
-      locality.endpoints.emplace_back(
-          address.addresses(),
-          address.args().Set(GRPC_ARG_ADDRESS_NAME, dns_name));
+      CHECK_EQ(address.addresses().size(), 1UL);
+      addresses.emplace_back(address.addresses().front());
+      CHECK_EQ(address_args, address.args());
     }
+    locality.endpoints.emplace_back(
+        std::move(addresses),
+        address_args.Set(GRPC_ARG_ADDRESS_NAME, dns_name));
     dns_state->update.resolution_note = std::move(result.resolution_note);
   } else if (result.resolution_note.empty()) {
     dns_state->update.resolution_note =

data/src/core/resolver/xds/xds_resolver.cc

@@ -46,6 +46,8 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "re2/re2.h"
+#include "src/core/call/metadata_batch.h"
+#include "src/core/call/status_util.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/config_selector.h"
 #include "src/core/config/core_configuration.h"
@@ -53,7 +55,6 @@
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/promise_based_filter.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -62,7 +63,6 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/load_balancing/ring_hash/ring_hash.h"
 #include "src/core/resolver/endpoint_addresses.h"
@@ -78,6 +78,7 @@
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
 #include "src/core/util/uri.h"
 #include "src/core/util/work_serializer.h"
@@ -690,7 +691,7 @@ absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
           XdsRouteConfigResource::Route::RouteAction::ClusterWeight>&
           /*weighted_clusters*/) {
         const uint32_t key = absl::Uniform<uint32_t>(
-            absl::BitGen(), 0, entry->weighted_cluster_state.back().range_end);
+            SharedBitGen(), 0, entry->weighted_cluster_state.back().range_end);
         // Find the index in weighted clusters corresponding to key.
         size_t mid = 0;
         size_t start_index = 0;