grpc 1.56.2 → 1.57.0.pre1

data/src/core/lib/iomgr/tcp_client_posix.cc

@@ -51,6 +51,7 @@
 #include "src/core/lib/iomgr/tcp_posix.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/iomgr/vsock.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 extern grpc_core::TraceFlag grpc_tcp_trace;
@@ -111,11 +112,13 @@ static grpc_error_handle prepare_socket(
     err = grpc_set_socket_rcvbuf(fd, options.tcp_receive_buffer_size);
     if (!err.ok()) goto error;
   }
-  if (!grpc_is_unix_socket(addr)) {
+  if (!grpc_is_unix_socket(addr) && !grpc_is_vsock(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
     if (!err.ok()) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
     if (!err.ok()) goto error;
+    err = grpc_set_socket_dscp(fd, options.dscp);
+    if (!err.ok()) goto error;
     err = grpc_set_socket_tcp_user_timeout(fd, options, true /* is_client */);
     if (!err.ok()) goto error;
   }

data/src/core/lib/iomgr/tcp_posix.cc

@@ -729,6 +729,9 @@ static void tcp_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
   grpc_tcp* tcp = reinterpret_cast<grpc_tcp*>(ep);
   ZerocopyDisableAndWaitForRemaining(tcp);
   grpc_fd_shutdown(tcp->em_fd, why);
+  tcp->read_mu.Lock();
+  tcp->memory_owner.Reset();
+  tcp->read_mu.Unlock();
 }
 
 static void tcp_free(grpc_tcp* tcp) {
@@ -775,6 +778,9 @@ static void tcp_destroy(grpc_endpoint* ep) {
     gpr_atm_no_barrier_store(&tcp->stop_error_notification, true);
     grpc_fd_set_error(tcp->em_fd);
   }
+  tcp->read_mu.Lock();
+  tcp->memory_owner.Reset();
+  tcp->read_mu.Unlock();
   TCP_UNREF(tcp, "destroy");
 }
 
@@ -795,11 +801,14 @@ static void maybe_post_reclaimer(grpc_tcp* tcp)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(tcp->read_mu) {
   if (!tcp->has_posted_reclaimer) {
     tcp->has_posted_reclaimer = true;
+    TCP_REF(tcp, "posted_reclaimer");
     tcp->memory_owner.PostReclaimer(
         grpc_core::ReclamationPass::kBenign,
         [tcp](absl::optional<grpc_core::ReclamationSweep> sweep) {
-          if (!sweep.has_value()) return;
-          perform_reclamation(tcp);
+          if (sweep.has_value()) {
+            perform_reclamation(tcp);
+          }
+          TCP_UNREF(tcp, "posted_reclaimer");
         });
   }
 }
@@ -1088,7 +1097,7 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
   }
   tcp->read_mu.Lock();
   grpc_error_handle tcp_read_error;
-  if (GPR_LIKELY(error.ok())) {
+  if (GPR_LIKELY(error.ok()) && tcp->memory_owner.is_valid()) {
     maybe_make_read_slices(tcp);
     if (!tcp_do_read(tcp, &tcp_read_error)) {
       // Maybe update rcv lowat value based on the number of bytes read in this
@@ -1101,7 +1110,12 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
     }
     tcp_trace_read(tcp, tcp_read_error);
   } else {
-    tcp_read_error = error;
+    if (!tcp->memory_owner.is_valid() && error.ok()) {
+      tcp_read_error =
+          tcp_annotate_error(absl::InternalError("Socket closed"), tcp);
+    } else {
+      tcp_read_error = error;
+    }
     grpc_slice_buffer_reset_and_unref(tcp->incoming_buffer);
     grpc_slice_buffer_reset_and_unref(&tcp->last_read_buffer);
   }
@@ -2031,6 +2045,9 @@ void grpc_tcp_destroy_and_release_fd(grpc_endpoint* ep, int* fd,
     gpr_atm_no_barrier_store(&tcp->stop_error_notification, true);
     grpc_fd_set_error(tcp->em_fd);
   }
+  tcp->read_mu.Lock();
+  tcp->memory_owner.Reset();
+  tcp->read_mu.Unlock();
   TCP_UNREF(tcp, "destroy");
 }
 

data/src/core/lib/iomgr/tcp_server_posix.cc

@@ -25,7 +25,6 @@
 // FIXME: "posix" files shouldn't be depending on _GNU_SOURCE
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
-#include <grpc/event_engine/event_engine.h>
 #endif
 
 #include "src/core/lib/iomgr/port.h"
@@ -50,6 +49,7 @@
 
 #include <grpc/byte_buffer.h>
 #include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -76,6 +76,7 @@
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/iomgr/vsock.h"
 #include "src/core/lib/resource_quota/api.h"
 #include "src/core/lib/transport/error_utils.h"
 
@@ -776,7 +777,7 @@ static void tcp_server_start(grpc_tcp_server* s,
   sp = s->head;
   while (sp != nullptr) {
     if (s->so_reuseport && !grpc_is_unix_socket(&sp->addr) &&
-        pollsets->size() > 1) {
+        !grpc_is_vsock(&sp->addr) && pollsets->size() > 1) {
       GPR_ASSERT(GRPC_LOG_IF_ERROR(
           "clone_port", clone_port(sp, (unsigned)(pollsets->size() - 1))));
       for (i = 0; i < pollsets->size(); i++) {

data/src/core/lib/iomgr/tcp_server_utils_posix_common.cc

@@ -44,6 +44,7 @@
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/tcp_server_utils_posix.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
+#include "src/core/lib/iomgr/vsock.h"
 
 #define MIN_SAFE_ACCEPT_QUEUE_SIZE 100
 
@@ -211,7 +212,7 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
 
   GPR_ASSERT(fd >= 0);
 
-  if (so_reuseport && !grpc_is_unix_socket(addr)) {
+  if (so_reuseport && !grpc_is_unix_socket(addr) && !grpc_is_vsock(addr)) {
     err = grpc_set_socket_reuse_port(fd, 1);
     if (!err.ok()) goto error;
   }
@@ -227,11 +228,13 @@ grpc_error_handle grpc_tcp_server_prepare_socket(
   if (!err.ok()) goto error;
   err = grpc_set_socket_cloexec(fd, 1);
   if (!err.ok()) goto error;
-  if (!grpc_is_unix_socket(addr)) {
+  if (!grpc_is_unix_socket(addr) && !grpc_is_vsock(addr)) {
     err = grpc_set_socket_low_latency(fd, 1);
     if (!err.ok()) goto error;
     err = grpc_set_socket_reuse_addr(fd, 1);
     if (!err.ok()) goto error;
+    err = grpc_set_socket_dscp(fd, s->options.dscp);
+    if (!err.ok()) goto error;
     err =
         grpc_set_socket_tcp_user_timeout(fd, s->options, false /* is_client */);
     if (!err.ok()) goto error;

data/src/core/lib/iomgr/tcp_windows.cc

@@ -186,9 +186,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
 
   if (error.ok()) {
     if (info->wsa_error != 0 && !tcp->shutting_down) {
-      char* utf8_message = gpr_format_message(info->wsa_error);
-      error = GRPC_ERROR_CREATE(utf8_message);
-      gpr_free(utf8_message);
+      error = GRPC_WSA_ERROR(info->wsa_error, "IOCP/Socket");
       grpc_slice_buffer_reset_and_unref(tcp->read_slices);
     } else {
       if (info->bytes_transferred != 0 && !tcp->shutting_down) {

data/src/core/lib/iomgr/vsock.cc

@@ -0,0 +1,59 @@
+//
+//
+// Copyright 2023 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.
+//
+//
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/vsock.h"
+
+#ifdef GRPC_HAVE_VSOCK
+
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "absl/strings/str_cat.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/transport/error_utils.h"
+
+absl::StatusOr<std::vector<grpc_resolved_address>> grpc_resolve_vsock_address(
+    absl::string_view name) {
+  grpc_resolved_address addr;
+  grpc_error_handle error = grpc_core::VSockaddrPopulate(name, &addr);
+  GRPC_RETURN_IF_ERROR(error);
+  return std::vector<grpc_resolved_address>({addr});
+}
+
+int grpc_is_vsock(const grpc_resolved_address* resolved_addr) {
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  return addr->sa_family == AF_VSOCK;
+}
+#else
+absl::StatusOr<std::vector<grpc_resolved_address>> grpc_resolve_vsock_address(
+    absl::string_view /*name*/) {
+  return absl::InvalidArgumentError("VSOCK is not supported.");
+}
+
+int grpc_is_vsock(const grpc_resolved_address* /*resolved_addr*/) { return 0; }
+#endif

data/src/core/lib/iomgr/vsock.h

@@ -0,0 +1,38 @@
+//
+//
+// Copyright 2023 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_LIB_IOMGR_VSOCK_H
+#define GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+
+#include <grpc/support/string_util.h>
+
+#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+
+absl::StatusOr<std::vector<grpc_resolved_address>> grpc_resolve_vsock_address(
+    absl::string_view name);
+
+int grpc_is_vsock(const grpc_resolved_address* resolved_addr);
+
+#endif /* GRPC_SRC_CORE_LIB_IOMGR_VSOCK_H */

data/src/core/lib/iomgr/wakeup_fd_posix.h

@@ -81,12 +81,9 @@ extern int grpc_allow_pipe_wakeup_fd;
 
 #define GRPC_WAKEUP_FD_GET_READ_FD(fd_info) ((fd_info)->read_fd)
 
-grpc_error_handle grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info)
-    GRPC_MUST_USE_RESULT;
-grpc_error_handle grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info)
-    GRPC_MUST_USE_RESULT;
-grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info)
-    GRPC_MUST_USE_RESULT;
+grpc_error_handle grpc_wakeup_fd_init(grpc_wakeup_fd* fd_info);
+grpc_error_handle grpc_wakeup_fd_consume_wakeup(grpc_wakeup_fd* fd_info);
+grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info);
 void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info);
 
 // Defined in some specialized implementation's .c file, or by

data/src/core/lib/load_balancing/delegating_helper.h

@@ -0,0 +1,115 @@
+//
+// Copyright 2023 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_LIB_LOAD_BALANCING_DELEGATING_HELPER_H
+#define GRPC_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/connectivity_state.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/load_balancing/lb_policy.h"
+#include "src/core/lib/load_balancing/subchannel_interface.h"
+#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/security/credentials/credentials.h"
+
+namespace grpc_core {
+
+/// A helper for use in parent policies.  All methods delegate to a
+/// parent policy's helper unless otherwise overridden.
+class LoadBalancingPolicy::DelegatingChannelControlHelper
+    : public LoadBalancingPolicy::ChannelControlHelper {
+ public:
+  RefCountedPtr<SubchannelInterface> CreateSubchannel(
+      ServerAddress address, const ChannelArgs& args) override {
+    return parent_helper()->CreateSubchannel(std::move(address), args);
+  }
+
+  void UpdateState(grpc_connectivity_state state, const absl::Status& status,
+                   RefCountedPtr<SubchannelPicker> picker) override {
+    parent_helper()->UpdateState(state, status, std::move(picker));
+  }
+
+  void RequestReresolution() override {
+    parent_helper()->RequestReresolution();
+  }
+
+  absl::string_view GetAuthority() override {
+    return parent_helper()->GetAuthority();
+  }
+
+  RefCountedPtr<grpc_channel_credentials> GetChannelCredentials() override {
+    return parent_helper()->GetChannelCredentials();
+  }
+
+  RefCountedPtr<grpc_channel_credentials> GetUnsafeChannelCredentials()
+      override {
+    return parent_helper()->GetUnsafeChannelCredentials();
+  }
+
+  grpc_event_engine::experimental::EventEngine* GetEventEngine() override {
+    return parent_helper()->GetEventEngine();
+  }
+
+  void AddTraceEvent(TraceSeverity severity,
+                     absl::string_view message) override {
+    parent_helper()->AddTraceEvent(severity, message);
+  }
+
+ private:
+  /// Returns the parent helper that we should delegate to by default.
+  virtual ChannelControlHelper* parent_helper() const = 0;
+};
+
+/// A delegating helper that owns a ref to the parent policy.
+template <typename ParentPolicy>
+class LoadBalancingPolicy::ParentOwningDelegatingChannelControlHelper
+    : public LoadBalancingPolicy::DelegatingChannelControlHelper {
+ public:
+  explicit ParentOwningDelegatingChannelControlHelper(
+      RefCountedPtr<ParentPolicy> parent)
+      : parent_(std::move(parent)) {}
+
+  ~ParentOwningDelegatingChannelControlHelper() override {
+    parent_.reset(DEBUG_LOCATION, "Helper");
+  }
+
+ protected:
+  ParentPolicy* parent() const {
+    return static_cast<ParentPolicy*>(parent_.get());
+  }
+
+  ChannelControlHelper* parent_helper() const override {
+    return parent_->channel_control_helper();
+  }
+
+ private:
+  RefCountedPtr<LoadBalancingPolicy> parent_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_LOAD_BALANCING_DELEGATING_HELPER_H

data/src/core/lib/load_balancing/lb_policy.h

@@ -35,6 +35,7 @@
 #include "absl/types/variant.h"
 
 #include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
@@ -297,6 +298,20 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// Returns the channel authority.
     virtual absl::string_view GetAuthority() = 0;
 
+    /// Returns the channel credentials from the parent channel.  This can
+    /// be used to create a control-plane channel inside an LB policy.
+    virtual RefCountedPtr<grpc_channel_credentials> GetChannelCredentials() = 0;
+
+    /// Returns the UNSAFE ChannelCredentials used to construct the channel,
+    /// including bearer tokens.  LB policies should generally have no use for
+    /// these credentials, and use of them is heavily discouraged.  These must
+    /// be used VERY carefully to avoid sending bearer tokens to untrusted
+    /// servers, as the server could then impersonate the client.  Generally,
+    /// it is safe to use these credentials only when communicating with the
+    /// backends.
+    virtual RefCountedPtr<grpc_channel_credentials>
+    GetUnsafeChannelCredentials() = 0;
+
     /// Returns the EventEngine to use for timers and async work.
     virtual grpc_event_engine::experimental::EventEngine* GetEventEngine() = 0;
 
@@ -306,6 +321,11 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
                                absl::string_view message) = 0;
   };
 
+  class DelegatingChannelControlHelper;
+
+  template <typename ParentPolicy>
+  class ParentOwningDelegatingChannelControlHelper;
+
   /// Interface for configuration data used by an LB policy implementation.
   /// Individual implementations will create a subclass that adds methods to
   /// return the parameters they need.

data/src/core/lib/load_balancing/subchannel_interface.h

@@ -97,6 +97,9 @@ class SubchannelInterface : public DualRefCounted<SubchannelInterface> {
   // Registers a new data watcher.
   virtual void AddDataWatcher(
       std::unique_ptr<DataWatcherInterface> watcher) = 0;
+
+  // Cancels a data watch.
+  virtual void CancelDataWatcher(DataWatcherInterface* watcher) = 0;
 };
 
 // A class that delegates to another subchannel, to be used in cases
@@ -125,6 +128,9 @@ class DelegatingSubchannel : public SubchannelInterface {
   void AddDataWatcher(std::unique_ptr<DataWatcherInterface> watcher) override {
     wrapped_subchannel_->AddDataWatcher(std::move(watcher));
   }
+  void CancelDataWatcher(DataWatcherInterface* watcher) override {
+    wrapped_subchannel_->CancelDataWatcher(watcher);
+  }
 
  private:
   RefCountedPtr<SubchannelInterface> wrapped_subchannel_;

data/src/core/lib/promise/party.h

@@ -384,7 +384,7 @@ class Party : public Activity, private Wakeable {
   // Should not be called by derived types except as a tail call to the base
   // class RunParty when overriding this method to add custom context.
   // Returns true if the party is over.
-  virtual bool RunParty() GRPC_MUST_USE_RESULT;
+  GRPC_MUST_USE_RESULT virtual bool RunParty();
 
   bool RefIfNonZero() { return sync_.RefIfNonZero(); }
 

data/src/core/lib/resolver/resolver_factory.h

@@ -66,9 +66,10 @@ class ResolverFactory {
   virtual OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const = 0;
 
   /// Returns a string representing the default authority to use for this
-  /// scheme.
+  /// scheme.  By default, we %-encode the path part of the target URI,
+  /// excluding the initial '/' character.
   virtual std::string GetDefaultAuthority(const URI& uri) const {
-    return std::string(absl::StripPrefix(uri.path(), "/"));
+    return URI::PercentEncodeAuthority(absl::StripPrefix(uri.path(), "/"));
   }
 };
 

data/src/core/lib/resolver/server_address.cc

@@ -23,8 +23,6 @@
 #include <string.h>
 
 #include <algorithm>
-#include <initializer_list>
-#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ -32,119 +30,49 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gpr/useful.h"
 
 // IWYU pragma: no_include <sys/socket.h>
 
 namespace grpc_core {
 
-//
-// ServerAddressWeightAttribute
-//
-const char* ServerAddressWeightAttribute::kServerAddressWeightAttributeKey =
-    "server_address_weight";
-
 //
 // ServerAddress
 //
 
-ServerAddress::ServerAddress(
-    const grpc_resolved_address& address, const ChannelArgs& args,
-    std::map<const char*, std::unique_ptr<AttributeInterface>> attributes)
-    : address_(address), args_(args), attributes_(std::move(attributes)) {}
+ServerAddress::ServerAddress(const grpc_resolved_address& address,
+                             const ChannelArgs& args)
+    : address_(address), args_(args) {}
 
 ServerAddress::ServerAddress(const ServerAddress& other)
-    : address_(other.address_), args_(other.args_) {
-  for (const auto& p : other.attributes_) {
-    attributes_[p.first] = p.second->Copy();
-  }
-}
+    : address_(other.address_), args_(other.args_) {}
+
 ServerAddress& ServerAddress::operator=(const ServerAddress& other) {
-  if (&other == this) {
-    return *this;
-  }
+  if (&other == this) return *this;
   address_ = other.address_;
   args_ = other.args_;
-  attributes_.clear();
-  for (const auto& p : other.attributes_) {
-    attributes_[p.first] = p.second->Copy();
-  }
   return *this;
 }
 
 ServerAddress::ServerAddress(ServerAddress&& other) noexcept
-    : address_(other.address_),
-      args_(std::move(other.args_)),
-      attributes_(std::move(other.attributes_)) {}
+    : address_(other.address_), args_(std::move(other.args_)) {}
 
 ServerAddress& ServerAddress::operator=(ServerAddress&& other) noexcept {
   address_ = other.address_;
   args_ = std::move(other.args_);
-  attributes_ = std::move(other.attributes_);
   return *this;
 }
 
-namespace {
-
-int CompareAttributes(
-    const std::map<const char*,
-                   std::unique_ptr<ServerAddress::AttributeInterface>>&
-        attributes1,
-    const std::map<const char*,
-                   std::unique_ptr<ServerAddress::AttributeInterface>>&
-        attributes2) {
-  auto it2 = attributes2.begin();
-  for (auto it1 = attributes1.begin(); it1 != attributes1.end(); ++it1) {
-    // attributes2 has fewer elements than attributes1
-    if (it2 == attributes2.end()) return -1;
-    // compare keys
-    int retval = strcmp(it1->first, it2->first);
-    if (retval != 0) return retval;
-    // compare values
-    retval = it1->second->Cmp(it2->second.get());
-    if (retval != 0) return retval;
-    ++it2;
-  }
-  // attributes1 has fewer elements than attributes2
-  if (it2 != attributes2.end()) return 1;
-  // equal
-  return 0;
-}
-
-}  // namespace
-
 int ServerAddress::Cmp(const ServerAddress& other) const {
   if (address_.len > other.address_.len) return 1;
   if (address_.len < other.address_.len) return -1;
   int retval = memcmp(address_.addr, other.address_.addr, address_.len);
   if (retval != 0) return retval;
-  retval = QsortCompare(args_, other.args_);
-  if (retval != 0) return retval;
-  return CompareAttributes(attributes_, other.attributes_);
-}
-
-const ServerAddress::AttributeInterface* ServerAddress::GetAttribute(
-    const char* key) const {
-  auto it = attributes_.find(key);
-  if (it == attributes_.end()) return nullptr;
-  return it->second.get();
-}
-
-// Returns a copy of the address with a modified attribute.
-// If the new value is null, the attribute is removed.
-ServerAddress ServerAddress::WithAttribute(
-    const char* key, std::unique_ptr<AttributeInterface> value) const {
-  ServerAddress address = *this;
-  if (value == nullptr) {
-    address.attributes_.erase(key);
-  } else {
-    address.attributes_[key] = std::move(value);
-  }
-  return address;
+  return QsortCompare(args_, other.args_);
 }
 
 std::string ServerAddress::ToString() const {
@@ -155,20 +83,7 @@ std::string ServerAddress::ToString() const {
   if (args_ != ChannelArgs()) {
     parts.emplace_back(absl::StrCat("args=", args_.ToString()));
   }
-  if (!attributes_.empty()) {
-    std::vector<std::string> attrs;
-    attrs.reserve(attributes_.size());
-    for (const auto& p : attributes_) {
-      attrs.emplace_back(absl::StrCat(p.first, "=", p.second->ToString()));
-    }
-    parts.emplace_back(
-        absl::StrCat("attributes={", absl::StrJoin(attrs, ", "), "}"));
-  }
   return absl::StrJoin(parts, " ");
 }
 
-std::string ServerAddressWeightAttribute::ToString() const {
-  return absl::StrFormat("%d", weight_);
-}
-
 }  // namespace grpc_core