grpc 1.32.0 → 1.33.0.pre1

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

@@ -17,12 +17,8 @@
 #include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/client_channel/config_selector.h"
-
 #include "src/core/lib/channel/channel_args.h"
 
-// Channel arg key for ConfigSelector.
-#define GRPC_ARG_CONFIG_SELECTOR "grpc.internal.config_selector"
-
 namespace grpc_core {
 
 namespace {

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

@@ -34,6 +34,9 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
+// Channel arg key for ConfigSelector.
+#define GRPC_ARG_CONFIG_SELECTOR "grpc.internal.config_selector"
+
 namespace grpc_core {
 
 // Internal API used to allow resolver implementations to override
@@ -52,6 +55,9 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
     // The per-method parsed configs that will be passed to
     // ServiceConfigCallData.
     const ServiceConfigParser::ParsedConfigVector* method_configs = nullptr;
+    // A ref to the service config that contains method_configs, held by
+    // the call to ensure that method_configs lives long enough.
+    RefCountedPtr<ServiceConfig> service_config;
     // Call attributes that will be accessible to LB policy implementations.
     std::map<const char*, absl::string_view> call_attributes;
     // A callback that, if set, will be invoked when the call is
@@ -62,6 +68,19 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
 
   virtual ~ConfigSelector() = default;
 
+  virtual const char* name() const = 0;
+
+  // Will be called only if the two objects have the same name, so
+  // subclasses can be free to safely down-cast the argument.
+  virtual bool Equals(const ConfigSelector* other) const = 0;
+
+  static bool Equals(const ConfigSelector* cs1, const ConfigSelector* cs2) {
+    if (cs1 == nullptr) return cs2 == nullptr;
+    if (cs2 == nullptr) return false;
+    if (strcmp(cs1->name(), cs2->name()) != 0) return false;
+    return cs1->Equals(cs2);
+  }
+
   virtual CallConfig GetCallConfig(GetCallConfigArgs args) = 0;
 
   grpc_arg MakeChannelArg() const;
@@ -73,14 +92,24 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
 class DefaultConfigSelector : public ConfigSelector {
  public:
   explicit DefaultConfigSelector(RefCountedPtr<ServiceConfig> service_config)
-      : service_config_(std::move(service_config)) {}
+      : service_config_(std::move(service_config)) {
+    // The client channel code ensures that this will never be null.
+    // If neither the resolver nor the client application provide a
+    // config, a default empty config will be used.
+    GPR_DEBUG_ASSERT(service_config_ != nullptr);
+  }
+
+  const char* name() const override { return "default"; }
+
+  // Only comparing the ConfigSelector itself, not the underlying
+  // service config, so we always return true.
+  bool Equals(const ConfigSelector* other) const override { return true; }
 
   CallConfig GetCallConfig(GetCallConfigArgs args) override {
     CallConfig call_config;
-    if (service_config_ != nullptr) {
-      call_config.method_configs =
-          service_config_->GetMethodParsedConfigVector(*args.path);
-    }
+    call_config.method_configs =
+        service_config_->GetMethodParsedConfigVector(*args.path);
+    call_config.service_config = service_config_;
     return call_config;
   }
 

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

@@ -279,7 +279,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
 
     /// Creates a new subchannel with the specified channel args.
     virtual RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        const grpc_channel_args& args) = 0;
+        ServerAddress address, const grpc_channel_args& args) = 0;
 
     /// Sets the connectivity state and returns a new picker to be used
     /// by the client channel.

data/src/core/ext/filters/client_channel/lb_policy/address_filtering.cc

@@ -18,64 +18,77 @@
 
 #include "src/core/ext/filters/client_channel/lb_policy/address_filtering.h"
 
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+
 #include "src/core/lib/channel/channel_args.h"
 
 #define GRPC_ARG_HIERARCHICAL_PATH "grpc.internal.address.hierarchical_path"
 
 namespace grpc_core {
 
+const char* kHierarchicalPathAttributeKey = "hierarchical_path";
+
 namespace {
 
-void* HierarchicalPathCopy(void* p) {
-  std::vector<std::string>* path = static_cast<std::vector<std::string>*>(p);
-  return static_cast<void*>(new std::vector<std::string>(*path));
-}
+class HierarchicalPathAttribute : public ServerAddress::AttributeInterface {
+ public:
+  explicit HierarchicalPathAttribute(std::vector<std::string> path)
+      : path_(std::move(path)) {}
 
-void HierarchicalPathDestroy(void* p) {
-  std::vector<std::string>* path = static_cast<std::vector<std::string>*>(p);
-  delete path;
-}
+  std::unique_ptr<AttributeInterface> Copy() const override {
+    return absl::make_unique<HierarchicalPathAttribute>(path_);
+  }
 
-int HierarchicalPathCompare(void* p1, void* p2) {
-  std::vector<std::string>* path1 = static_cast<std::vector<std::string>*>(p1);
-  std::vector<std::string>* path2 = static_cast<std::vector<std::string>*>(p2);
-  for (size_t i = 0; i < path1->size(); ++i) {
-    if (path2->size() == i) return 1;
-    int r = (*path1)[i].compare((*path2)[i]);
-    if (r != 0) return r;
+  int Cmp(const AttributeInterface* other) const override {
+    const std::vector<std::string>& other_path =
+        static_cast<const HierarchicalPathAttribute*>(other)->path_;
+    for (size_t i = 0; i < path_.size(); ++i) {
+      if (other_path.size() == i) return 1;
+      int r = path_[i].compare(other_path[i]);
+      if (r != 0) return r;
+    }
+    if (other_path.size() > path_.size()) return -1;
+    return 0;
   }
-  if (path2->size() > path1->size()) return -1;
-  return 0;
-}
 
-const grpc_arg_pointer_vtable hierarchical_path_arg_vtable = {
-    HierarchicalPathCopy, HierarchicalPathDestroy, HierarchicalPathCompare};
+  std::string ToString() const override {
+    return absl::StrCat("[", absl::StrJoin(path_, ", "), "]");
+  }
+
+  const std::vector<std::string>& path() const { return path_; }
+
+ private:
+  std::vector<std::string> path_;
+};
 
 }  // namespace
 
-grpc_arg MakeHierarchicalPathArg(const std::vector<std::string>& path) {
-  return grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_HIERARCHICAL_PATH),
-      const_cast<std::vector<std::string>*>(&path),
-      &hierarchical_path_arg_vtable);
+std::unique_ptr<ServerAddress::AttributeInterface>
+MakeHierarchicalPathAttribute(std::vector<std::string> path) {
+  return absl::make_unique<HierarchicalPathAttribute>(std::move(path));
 }
 
 HierarchicalAddressMap MakeHierarchicalAddressMap(
     const ServerAddressList& addresses) {
   HierarchicalAddressMap result;
   for (const ServerAddress& address : addresses) {
-    auto* path = grpc_channel_args_find_pointer<std::vector<std::string>>(
-        address.args(), GRPC_ARG_HIERARCHICAL_PATH);
-    if (path == nullptr || path->empty()) continue;
-    auto it = path->begin();
+    const HierarchicalPathAttribute* path_attribute =
+        static_cast<const HierarchicalPathAttribute*>(
+            address.GetAttribute(kHierarchicalPathAttributeKey));
+    if (path_attribute == nullptr) continue;
+    const std::vector<std::string>& path = path_attribute->path();
+    auto it = path.begin();
     ServerAddressList& target_list = result[*it];
+    std::unique_ptr<HierarchicalPathAttribute> new_attribute;
     ++it;
-    std::vector<std::string> remaining_path(it, path->end());
-    const char* name_to_remove = GRPC_ARG_HIERARCHICAL_PATH;
-    grpc_arg new_arg = MakeHierarchicalPathArg(remaining_path);
-    grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
-        address.args(), &name_to_remove, 1, &new_arg, 1);
-    target_list.emplace_back(address.address(), new_args);
+    if (it != path.end()) {
+      std::vector<std::string> remaining_path(it, path.end());
+      new_attribute = absl::make_unique<HierarchicalPathAttribute>(
+          std::move(remaining_path));
+    }
+    target_list.emplace_back(address.WithAttribute(
+        kHierarchicalPathAttributeKey, std::move(new_attribute)));
   }
   return result;
 }

data/src/core/ext/filters/client_channel/lb_policy/address_filtering.h

@@ -23,8 +23,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/strings/string_view.h"
-
 #include "src/core/ext/filters/client_channel/server_address.h"
 
 // The resolver returns a flat list of addresses.  When a hierarchy of
@@ -81,9 +79,13 @@
 
 namespace grpc_core {
 
-// Constructs a channel arg containing the hierarchical path
-// to be associated with an address.
-grpc_arg MakeHierarchicalPathArg(const std::vector<std::string>& path);
+// The attribute key to be used for hierarchical paths in ServerAddress.
+extern const char* kHierarchicalPathAttributeKey;
+
+// Constructs an address attribute containing the hierarchical path
+// to be associated with the address.
+std::unique_ptr<ServerAddress::AttributeInterface>
+MakeHierarchicalPathAttribute(std::vector<std::string> path);
 
 // A map from the next path element to the addresses that fall under
 // that path element.

data/src/core/ext/filters/client_channel/lb_policy/child_policy_handler.cc

@@ -39,10 +39,11 @@ class ChildPolicyHandler::Helper
   ~Helper() { parent_.reset(DEBUG_LOCATION, "Helper"); }
 
   RefCountedPtr<SubchannelInterface> CreateSubchannel(
-      const grpc_channel_args& args) override {
+      ServerAddress address, const grpc_channel_args& args) override {
     if (parent_->shutting_down_) return nullptr;
     if (!CalledByCurrentChild() && !CalledByPendingChild()) return nullptr;
-    return parent_->channel_control_helper()->CreateSubchannel(args);
+    return parent_->channel_control_helper()->CreateSubchannel(
+        std::move(address), args);
   }
 
   void UpdateState(grpc_connectivity_state state, const absl::Status& status,

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc

@@ -124,6 +124,8 @@ TraceFlag grpc_lb_glb_trace(false, "glb");
 const char kGrpcLbClientStatsMetadataKey[] = "grpclb_client_stats";
 const char kGrpcLbLbTokenMetadataKey[] = "lb-token";
 
+const char kGrpcLbAddressAttributeKey[] = "grpclb";
+
 namespace {
 
 constexpr char kGrpclb[] = "grpclb";
@@ -233,6 +235,40 @@ class GrpcLb : public LoadBalancingPolicy {
     grpc_closure client_load_report_closure_;
   };
 
+  class TokenAndClientStatsAttribute
+      : public ServerAddress::AttributeInterface {
+   public:
+    TokenAndClientStatsAttribute(std::string lb_token,
+                                 RefCountedPtr<GrpcLbClientStats> client_stats)
+        : lb_token_(std::move(lb_token)),
+          client_stats_(std::move(client_stats)) {}
+
+    std::unique_ptr<AttributeInterface> Copy() const override {
+      return absl::make_unique<TokenAndClientStatsAttribute>(lb_token_,
+                                                             client_stats_);
+    }
+
+    int Cmp(const AttributeInterface* other_base) const override {
+      const TokenAndClientStatsAttribute* other =
+          static_cast<const TokenAndClientStatsAttribute*>(other_base);
+      int r = lb_token_.compare(other->lb_token_);
+      if (r != 0) return r;
+      return GPR_ICMP(client_stats_.get(), other->client_stats_.get());
+    }
+
+    std::string ToString() const override {
+      return absl::StrFormat("lb_token=\"%s\" client_stats=%p", lb_token_,
+                             client_stats_.get());
+    }
+
+    const std::string& lb_token() const { return lb_token_; }
+    GrpcLbClientStats* client_stats() const { return client_stats_.get(); }
+
+   private:
+    std::string lb_token_;
+    RefCountedPtr<GrpcLbClientStats> client_stats_;
+  };
+
   class Serverlist : public RefCounted<Serverlist> {
    public:
     // Takes ownership of serverlist.
@@ -302,7 +338,7 @@ class GrpcLb : public LoadBalancingPolicy {
         : parent_(std::move(parent)) {}
 
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
-        const grpc_channel_args& args) override;
+        ServerAddress address, const grpc_channel_args& args) override;
     void UpdateState(grpc_connectivity_state state, const absl::Status& status,
                      std::unique_ptr<SubchannelPicker> picker) override;
     void RequestReresolution() override;
@@ -352,6 +388,8 @@ class GrpcLb : public LoadBalancingPolicy {
   // Helper functions used in UpdateLocked().
   void ProcessAddressesAndChannelArgsLocked(const ServerAddressList& addresses,
                                             const grpc_channel_args& args);
+  static ServerAddressList AddNullLbTokenToAddresses(
+      const ServerAddressList& addresses);
 
   void CancelBalancerChannelConnectivityWatchLocked();
 
@@ -389,6 +427,8 @@ class GrpcLb : public LoadBalancingPolicy {
   StateWatcher* watcher_ = nullptr;
   // Response generator to inject address updates into lb_channel_.
   RefCountedPtr<FakeResolverResponseGenerator> response_generator_;
+  // Parent channelz node.
+  RefCountedPtr<channelz::ChannelNode> parent_channelz_node_;
 
   // The data associated with the current LB call. It holds a ref to this LB
   // policy. It's initialized every time we query for backends. It's reset to
@@ -473,44 +513,6 @@ std::string GrpcLb::Serverlist::AsText() const {
   return absl::StrJoin(entries, "");
 }
 
-// vtables for channel args for LB token and client stats.
-void* lb_token_copy(void* token) {
-  return gpr_strdup(static_cast<char*>(token));
-}
-void lb_token_destroy(void* token) { gpr_free(token); }
-void* client_stats_copy(void* p) {
-  GrpcLbClientStats* client_stats = static_cast<GrpcLbClientStats*>(p);
-  client_stats->Ref().release();
-  return p;
-}
-void client_stats_destroy(void* p) {
-  GrpcLbClientStats* client_stats = static_cast<GrpcLbClientStats*>(p);
-  client_stats->Unref();
-}
-int equal_cmp(void* /*p1*/, void* /*p2*/) {
-  // Always indicate a match, since we don't want this channel arg to
-  // affect the subchannel's key in the index.
-  // TODO(roth): Is this right?  This does prevent us from needlessly
-  // recreating the subchannel whenever the LB token or client stats
-  // changes (i.e., when the balancer call is terminated and reestablished).
-  // However, it means that we don't actually recreate the subchannel,
-  // which means that we won't ever switch over to using the new LB
-  // token or client stats.  A better approach might be to find somewhere
-  // other than the subchannel args to store the LB token and client
-  // stats.  They could be stored in a map and then looked up for each
-  // call. Or we could do something more complicated whereby
-  // we create our own subchannel wrapper to store them, although that would
-  // involve a lot of refcounting overhead.
-  // Given that we're trying to move from grpclb to xds at this point,
-  // and that no one has actually reported any problems with this, we
-  // probably won't bother fixing this at this point.
-  return 0;
-}
-const grpc_arg_pointer_vtable lb_token_arg_vtable = {
-    lb_token_copy, lb_token_destroy, equal_cmp};
-const grpc_arg_pointer_vtable client_stats_arg_vtable = {
-    client_stats_copy, client_stats_destroy, equal_cmp};
-
 bool IsServerValid(const GrpcLbServer& server, size_t idx, bool log) {
   if (server.drop) return false;
   if (GPR_UNLIKELY(server.port >> 16 != 0)) {
@@ -536,6 +538,8 @@ bool IsServerValid(const GrpcLbServer& server, size_t idx, bool log) {
 // Returns addresses extracted from the serverlist.
 ServerAddressList GrpcLb::Serverlist::GetServerAddressList(
     GrpcLbClientStats* client_stats) const {
+  RefCountedPtr<GrpcLbClientStats> stats;
+  if (client_stats != nullptr) stats = client_stats->Ref();
   ServerAddressList addresses;
   for (size_t i = 0; i < serverlist_.size(); ++i) {
     const GrpcLbServer& server = serverlist_[i];
@@ -544,34 +548,23 @@ ServerAddressList GrpcLb::Serverlist::GetServerAddressList(
     grpc_resolved_address addr;
     ParseServer(server, &addr);
     // LB token processing.
-    char lb_token[GPR_ARRAY_SIZE(server.load_balance_token) + 1];
-    if (server.load_balance_token[0] != 0) {
-      const size_t lb_token_max_length =
-          GPR_ARRAY_SIZE(server.load_balance_token);
-      const size_t lb_token_length =
-          strnlen(server.load_balance_token, lb_token_max_length);
-      memcpy(lb_token, server.load_balance_token, lb_token_length);
-      lb_token[lb_token_length] = '\0';
-    } else {
+    const size_t lb_token_length = strnlen(
+        server.load_balance_token, GPR_ARRAY_SIZE(server.load_balance_token));
+    std::string lb_token(server.load_balance_token, lb_token_length);
+    if (lb_token.empty()) {
       gpr_log(GPR_INFO,
               "Missing LB token for backend address '%s'. The empty token will "
               "be used instead",
               grpc_sockaddr_to_uri(&addr).c_str());
-      lb_token[0] = '\0';
     }
+    // Attach attribute to address containing LB token and stats object.
+    std::map<const char*, std::unique_ptr<ServerAddress::AttributeInterface>>
+        attributes;
+    attributes[kGrpcLbAddressAttributeKey] =
+        absl::make_unique<TokenAndClientStatsAttribute>(std::move(lb_token),
+                                                        stats);
     // Add address.
-    absl::InlinedVector<grpc_arg, 2> args_to_add;
-    args_to_add.emplace_back(grpc_channel_arg_pointer_create(
-        const_cast<char*>(GRPC_ARG_GRPCLB_ADDRESS_LB_TOKEN), lb_token,
-        &lb_token_arg_vtable));
-    if (client_stats != nullptr) {
-      args_to_add.emplace_back(grpc_channel_arg_pointer_create(
-          const_cast<char*>(GRPC_ARG_GRPCLB_ADDRESS_CLIENT_STATS), client_stats,
-          &client_stats_arg_vtable));
-    }
-    grpc_channel_args* args = grpc_channel_args_copy_and_add(
-        nullptr, args_to_add.data(), args_to_add.size());
-    addresses.emplace_back(addr, args);
+    addresses.emplace_back(addr, /*args=*/nullptr, std::move(attributes));
   }
   return addresses;
 }
@@ -616,15 +609,18 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
   // If pick succeeded, add LB token to initial metadata.
   if (result.type == PickResult::PICK_COMPLETE &&
       result.subchannel != nullptr) {
+    const TokenAndClientStatsAttribute* attribute =
+        static_cast<const TokenAndClientStatsAttribute*>(
+            result.subchannel->GetAttribute(kGrpcLbAddressAttributeKey));
+    if (attribute == nullptr) {
+      gpr_log(GPR_ERROR, "[grpclb %p picker %p] No LB token for subchannel %p",
+              parent_, this, result.subchannel.get());
+      abort();
+    }
     // Encode client stats object into metadata for use by
     // client_load_reporting filter.
-    const grpc_arg* arg =
-        grpc_channel_args_find(result.subchannel->channel_args(),
-                               GRPC_ARG_GRPCLB_ADDRESS_CLIENT_STATS);
-    if (arg != nullptr && arg->type == GRPC_ARG_POINTER &&
-        arg->value.pointer.p != nullptr) {
-      GrpcLbClientStats* client_stats =
-          static_cast<GrpcLbClientStats*>(arg->value.pointer.p);
+    GrpcLbClientStats* client_stats = attribute->client_stats();
+    if (client_stats != nullptr) {
       client_stats->Ref().release();  // Ref passed via metadata.
       // The metadata value is a hack: we pretend the pointer points to
       // a string and rely on the client_load_reporting filter to know
@@ -636,15 +632,13 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
       client_stats->AddCallStarted();
     }
     // Encode the LB token in metadata.
-    arg = grpc_channel_args_find(result.subchannel->channel_args(),
-                                 GRPC_ARG_GRPCLB_ADDRESS_LB_TOKEN);
-    if (arg == nullptr) {
-      gpr_log(GPR_ERROR, "[grpclb %p picker %p] No LB token for subchannel %p",
-              parent_, this, result.subchannel.get());
-      abort();
-    }
-    args.initial_metadata->Add(kGrpcLbLbTokenMetadataKey,
-                               static_cast<char*>(arg->value.pointer.p));
+    // Create a new copy on the call arena, since the subchannel list
+    // may get refreshed between when we return this pick and when the
+    // initial metadata goes out on the wire.
+    char* lb_token = static_cast<char*>(
+        args.call_state->Alloc(attribute->lb_token().size() + 1));
+    strcpy(lb_token, attribute->lb_token().c_str());
+    args.initial_metadata->Add(kGrpcLbLbTokenMetadataKey, lb_token);
   }
   return result;
 }
@@ -654,9 +648,10 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
 //
 
 RefCountedPtr<SubchannelInterface> GrpcLb::Helper::CreateSubchannel(
-    const grpc_channel_args& args) {
+    ServerAddress address, const grpc_channel_args& args) {
   if (parent_->shutting_down_) return nullptr;
-  return parent_->channel_control_helper()->CreateSubchannel(args);
+  return parent_->channel_control_helper()->CreateSubchannel(std::move(address),
+                                                             args);
 }
 
 void GrpcLb::Helper::UpdateState(grpc_connectivity_state state,
@@ -1287,25 +1282,18 @@ grpc_channel_args* BuildBalancerChannelArgs(
       GRPC_ARG_CHANNELZ_CHANNEL_NODE,
   };
   // Channel args to add.
-  absl::InlinedVector<grpc_arg, 3> args_to_add;
-  // The fake resolver response generator, which we use to inject
-  // address updates into the LB channel.
-  args_to_add.emplace_back(
+  absl::InlinedVector<grpc_arg, 3> args_to_add = {
+      // The fake resolver response generator, which we use to inject
+      // address updates into the LB channel.
       grpc_core::FakeResolverResponseGenerator::MakeChannelArg(
-          response_generator));
-  // A channel arg indicating the target is a grpclb load balancer.
-  args_to_add.emplace_back(grpc_channel_arg_integer_create(
-      const_cast<char*>(GRPC_ARG_ADDRESS_IS_GRPCLB_LOAD_BALANCER), 1));
-  // The parent channel's channelz uuid.
-  channelz::ChannelNode* channelz_node = nullptr;
-  const grpc_arg* arg =
-      grpc_channel_args_find(args, GRPC_ARG_CHANNELZ_CHANNEL_NODE);
-  if (arg != nullptr && arg->type == GRPC_ARG_POINTER &&
-      arg->value.pointer.p != nullptr) {
-    channelz_node = static_cast<channelz::ChannelNode*>(arg->value.pointer.p);
-    args_to_add.emplace_back(
-        channelz::MakeParentUuidArg(channelz_node->uuid()));
-  }
+          response_generator),
+      // A channel arg indicating the target is a grpclb load balancer.
+      grpc_channel_arg_integer_create(
+          const_cast<char*>(GRPC_ARG_ADDRESS_IS_GRPCLB_LOAD_BALANCER), 1),
+      // Tells channelz that this is an internal channel.
+      grpc_channel_arg_integer_create(
+          const_cast<char*>(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL), 1),
+  };
   // Construct channel args.
   grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
       args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove), args_to_add.data(),
@@ -1382,6 +1370,12 @@ void GrpcLb::ShutdownLocked() {
   // OnBalancerChannelConnectivityChangedLocked(), and we need to be
   // alive when that callback is invoked.
   if (lb_channel_ != nullptr) {
+    if (parent_channelz_node_ != nullptr) {
+      channelz::ChannelNode* child_channelz_node =
+          grpc_channel_get_channelz_node(lb_channel_);
+      GPR_ASSERT(child_channelz_node != nullptr);
+      parent_channelz_node_->RemoveChildChannel(child_channelz_node->uuid());
+    }
     grpc_channel_destroy(lb_channel_);
     lb_channel_ = nullptr;
   }
@@ -1435,17 +1429,13 @@ void GrpcLb::UpdateLocked(UpdateArgs args) {
 // helpers for UpdateLocked()
 //
 
-ServerAddressList AddNullLbTokenToAddresses(
+ServerAddressList GrpcLb::AddNullLbTokenToAddresses(
     const ServerAddressList& addresses) {
-  static const char* lb_token = "";
-  grpc_arg arg = grpc_channel_arg_pointer_create(
-      const_cast<char*>(GRPC_ARG_GRPCLB_ADDRESS_LB_TOKEN),
-      const_cast<char*>(lb_token), &lb_token_arg_vtable);
   ServerAddressList addresses_out;
-  for (size_t i = 0; i < addresses.size(); ++i) {
-    addresses_out.emplace_back(
-        addresses[i].address(),
-        grpc_channel_args_copy_and_add(addresses[i].args(), &arg, 1));
+  for (const ServerAddress& address : addresses) {
+    addresses_out.emplace_back(address.WithAttribute(
+        kGrpcLbAddressAttributeKey,
+        absl::make_unique<TokenAndClientStatsAttribute>("", nullptr)));
   }
   return addresses_out;
 }
@@ -1472,6 +1462,16 @@ void GrpcLb::ProcessAddressesAndChannelArgsLocked(
     lb_channel_ =
         CreateGrpclbBalancerChannel(uri_str.c_str(), *lb_channel_args);
     GPR_ASSERT(lb_channel_ != nullptr);
+    // Set up channelz linkage.
+    channelz::ChannelNode* child_channelz_node =
+        grpc_channel_get_channelz_node(lb_channel_);
+    channelz::ChannelNode* parent_channelz_node =
+        grpc_channel_args_find_pointer<channelz::ChannelNode>(
+            &args, GRPC_ARG_CHANNELZ_CHANNEL_NODE);
+    if (child_channelz_node != nullptr && parent_channelz_node != nullptr) {
+      parent_channelz_node->AddChildChannel(child_channelz_node->uuid());
+      parent_channelz_node_ = parent_channelz_node->Ref();
+    }
   }
   // Propagate updates to the LB channel (pick_first) through the fake
   // resolver.