grpc 1.60.0 → 1.61.0.pre2

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_override_host.cc

@@ -18,11 +18,9 @@
 
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_override_host.h"
 
-#include <inttypes.h>
 #include <stddef.h>
 
 #include <algorithm>
-#include <atomic>
 #include <functional>
 #include <map>
 #include <memory>
@@ -34,6 +32,7 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/functional/function_ref.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -44,13 +43,16 @@
 #include "absl/types/span.h"
 #include "absl/types/variant.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/client_channel_internal.h"
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
+#include "src/core/ext/filters/client_channel/resolver/xds/xds_dependency_manager.h"
 #include "src/core/ext/filters/stateful_session/stateful_session_filter.h"
 #include "src/core/ext/xds/xds_health_status.h"
+#include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -82,6 +84,9 @@
 #include "src/core/lib/transport/connectivity_state.h"
 
 namespace grpc_core {
+
+using ::grpc_event_engine::experimental::EventEngine;
+
 TraceFlag grpc_lb_xds_override_host_trace(false, "xds_override_host_lb");
 
 namespace {
@@ -102,16 +107,10 @@ struct PtrLessThan {
   }
 };
 
-XdsHealthStatus GetEndpointHealthStatus(const EndpointAddresses& endpoint) {
-  return XdsHealthStatus(static_cast<XdsHealthStatus::HealthStatus>(
-      endpoint.args()
-          .GetInt(GRPC_ARG_XDS_HEALTH_STATUS)
-          .value_or(XdsHealthStatus::HealthStatus::kUnknown)));
-}
-
 //
 // xds_override_host LB policy
 //
+
 class XdsOverrideHostLb : public LoadBalancingPolicy {
  public:
   explicit XdsOverrideHostLb(Args args);
@@ -125,12 +124,18 @@ class XdsOverrideHostLb : public LoadBalancingPolicy {
   void ResetBackoffLocked() override;
 
  private:
+  class SubchannelEntry;
+
   class SubchannelWrapper : public DelegatingSubchannel {
    public:
     SubchannelWrapper(RefCountedPtr<SubchannelInterface> subchannel,
                       RefCountedPtr<XdsOverrideHostLb> policy);
 
-    ~SubchannelWrapper() override;
+    // Called immediately after construction.  We use two-phase initialization
+    // to avoid doing an allocation while holding the lock.
+    void set_subchannel_entry(RefCountedPtr<SubchannelEntry> subchannel_entry) {
+      subchannel_entry_ = std::move(subchannel_entry);
+    }
 
     void WatchConnectivityState(
         std::unique_ptr<ConnectivityStateWatcherInterface> watcher) override;
@@ -138,14 +143,24 @@ class XdsOverrideHostLb : public LoadBalancingPolicy {
     void CancelConnectivityStateWatch(
         ConnectivityStateWatcherInterface* watcher) override;
 
-    grpc_connectivity_state connectivity_state() {
-      return connectivity_state_.load();
+    RefCountedStringValue address_list() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      return subchannel_entry_->address_list();
     }
 
-    XdsOverrideHostLb* policy() { return policy_.get(); }
+    void set_last_used_time()
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      subchannel_entry_->set_last_used_time();
+    }
+
+    XdsOverrideHostLb* policy() const { return policy_.get(); }
 
-    void set_key(absl::string_view key) { key_ = std::string(key); }
-    const absl::optional<std::string>& key() const { return key_; }
+    RefCountedPtr<SubchannelWrapper> Clone() const {
+      auto subchannel =
+          MakeRefCounted<SubchannelWrapper>(wrapped_subchannel(), policy_);
+      subchannel->set_subchannel_entry(subchannel_entry_);
+      return subchannel;
+    }
 
    private:
     class ConnectivityStateWatcher : public ConnectivityStateWatcherInterface {
@@ -155,9 +170,13 @@ class XdsOverrideHostLb : public LoadBalancingPolicy {
           : subchannel_(std::move(subchannel)) {}
 
       void OnConnectivityStateChange(grpc_connectivity_state state,
-                                     absl::Status status) override;
+                                     absl::Status status) override {
+        subchannel_->UpdateConnectivityState(state, status);
+      }
 
-      grpc_pollset_set* interested_parties() override;
+      grpc_pollset_set* interested_parties() override {
+        return subchannel_->policy()->interested_parties();
+      }
 
      private:
       WeakRefCountedPtr<SubchannelWrapper> subchannel_;
@@ -168,68 +187,129 @@ class XdsOverrideHostLb : public LoadBalancingPolicy {
     void UpdateConnectivityState(grpc_connectivity_state state,
                                  absl::Status status);
 
-    ConnectivityStateWatcher* watcher_;
-    absl::optional<std::string> key_;
     RefCountedPtr<XdsOverrideHostLb> policy_;
+    RefCountedPtr<SubchannelEntry> subchannel_entry_;
+    ConnectivityStateWatcher* watcher_;
     std::set<std::unique_ptr<ConnectivityStateWatcherInterface>,
              PtrLessThan<ConnectivityStateWatcherInterface>>
         watchers_;
-    std::atomic<grpc_connectivity_state> connectivity_state_ = {
-        GRPC_CHANNEL_IDLE};
   };
 
-  class SubchannelEntry {
+  // An entry in the subchannel map.
+  //
+  // The entry may hold either an owned (RefCountedPtr<>) or unowned
+  // (raw pointer) SubchannelWrapper, but not both.  It will be unowned
+  // in the case where the SubchannelWrapper is owned by the child policy.
+  // It will be owned in the case where the child policy has not created a
+  // subchannel but we have RPCs whose cookies point to that address.
+  //
+  // Note that when a SubchannelWrapper is orphaned, it will try to
+  // acquire the lock to remove itself from the entry.  This means that
+  // whenever we need to remove an owned subchannel from an entry, if we
+  // released our ref to the SubchannelWrapper immediately, we would
+  // cause a deadlock, since our caller is already holding the lock.  To
+  // avoid that, any method that may result in releasing a ref to the
+  // SubchannelWrapper will instead return that ref to the caller, who is
+  // responsible for releasing the ref after releasing the lock.
+  class SubchannelEntry : public RefCounted<SubchannelEntry> {
    public:
-    explicit SubchannelEntry(XdsHealthStatus eds_health_status)
-        : eds_health_status_(eds_health_status) {}
-
-    void SetSubchannel(SubchannelWrapper* subchannel) {
-      if (eds_health_status_.status() == XdsHealthStatus::kDraining) {
-        subchannel_ = subchannel->Ref();
-      } else {
-        subchannel_ = subchannel->WeakRef();
-      }
+    bool HasOwnedSubchannel() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      auto* sc = absl::get_if<RefCountedPtr<SubchannelWrapper>>(&subchannel_);
+      return sc != nullptr && *sc != nullptr;
     }
 
-    void UnsetSubchannel() {
-      subchannel_ = WeakRefCountedPtr<SubchannelWrapper>(nullptr);
+    // Sets the unowned subchannel.  If the entry previously had an
+    // owned subchannel, returns the ref to it.
+    RefCountedPtr<SubchannelWrapper> SetUnownedSubchannel(
+        SubchannelWrapper* subchannel)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_);
+
+    // Sets the owned subchannel.  Must not be called if the entry
+    // already has an owned subchannel.
+    void SetOwnedSubchannel(RefCountedPtr<SubchannelWrapper> subchannel)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      GPR_DEBUG_ASSERT(!HasOwnedSubchannel());
+      subchannel_ = std::move(subchannel);
     }
 
-    SubchannelWrapper* GetSubchannel() const {
-      return Match(
-          subchannel_,
-          [](WeakRefCountedPtr<XdsOverrideHostLb::SubchannelWrapper>
-                 subchannel) { return subchannel.get(); },
-          [](RefCountedPtr<XdsOverrideHostLb::SubchannelWrapper> subchannel) {
-            return subchannel.get();
-          });
+    // Returns a pointer to the subchannel, regardless of whether it's
+    // owned or not.
+    SubchannelWrapper* GetSubchannel() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_);
+
+    // Returns a ref to the subchannel, regardless of whether it's owned
+    // or not.  Returns null if there is no subchannel or if the
+    // subchannel's ref count is 0.
+    RefCountedPtr<SubchannelWrapper> GetSubchannelRef() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_);
+
+    // If the entry has an owned subchannel, moves it out of the entry
+    // and returns it.
+    RefCountedPtr<SubchannelWrapper> TakeOwnedSubchannel()
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_);
+
+    // Unsets the entry's subchannel.
+    // If the entry had an owned subchannel, moves the ref into
+    // owned_subchannels.
+    void UnsetSubchannel(
+        std::vector<RefCountedPtr<SubchannelWrapper>>* owned_subchannels)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_);
+
+    // Called when a SubchannelWrapper is orphaned.  May replace the
+    // unowned SubchannelWrapper with an owned one based on
+    // last_used_time_ and connection_idle_timeout.
+    void OnSubchannelWrapperOrphan(SubchannelWrapper* wrapper,
+                                   Duration connection_idle_timeout)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_);
+
+    grpc_connectivity_state connectivity_state() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      return connectivity_state_;
+    }
+    void set_connectivity_state(grpc_connectivity_state state)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      connectivity_state_ = state;
     }
 
-    void SetEdsHealthStatus(XdsHealthStatus eds_health_status) {
+    XdsHealthStatus eds_health_status() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      return eds_health_status_;
+    }
+    void set_eds_health_status(XdsHealthStatus eds_health_status)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
       eds_health_status_ = eds_health_status;
-      auto subchannel = GetSubchannel();
-      if (subchannel == nullptr) return;
-      if (eds_health_status_.status() == XdsHealthStatus::kDraining) {
-        subchannel_ = subchannel->Ref();
-      } else {
-        subchannel_ = subchannel->WeakRef();
-      }
     }
 
-    XdsHealthStatus eds_health_status() const { return eds_health_status_; }
-
-    void set_address_list(RefCountedStringValue address_list) {
+    RefCountedStringValue address_list() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      return address_list_;
+    }
+    void set_address_list(RefCountedStringValue address_list)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
       address_list_ = std::move(address_list);
     }
 
-    RefCountedStringValue address_list() const { return address_list_; }
+    Timestamp last_used_time() const
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      return last_used_time_;
+    }
+    void set_last_used_time()
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+      last_used_time_ = Timestamp::Now();
+    }
 
    private:
-    absl::variant<WeakRefCountedPtr<SubchannelWrapper>,
-                  RefCountedPtr<SubchannelWrapper>>
-        subchannel_;
-    XdsHealthStatus eds_health_status_;
-    RefCountedStringValue address_list_;
+    grpc_connectivity_state connectivity_state_
+        ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_) = GRPC_CHANNEL_IDLE;
+    absl::variant<SubchannelWrapper*, RefCountedPtr<SubchannelWrapper>>
+        subchannel_ ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_);
+    XdsHealthStatus eds_health_status_ ABSL_GUARDED_BY(
+        &XdsOverrideHostLb::mu_) = XdsHealthStatus(XdsHealthStatus::kUnknown);
+    RefCountedStringValue address_list_
+        ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_);
+    Timestamp last_used_time_ ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_) =
+        Timestamp::InfPast();
   };
 
   // A picker that wraps the picker from the child for cases when cookie is
@@ -249,8 +329,8 @@ class XdsOverrideHostLb : public LoadBalancingPolicy {
           RefCountedPtr<SubchannelWrapper> subchannel)
           : subchannel_(std::move(subchannel)) {
         GRPC_CLOSURE_INIT(&closure_, RunInExecCtx, this, nullptr);
-        // Hop into ExecCtx, so that we're not holding the data plane mutex
-        // while we run control-plane code.
+        // 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());
       }
 
@@ -269,6 +349,33 @@ class XdsOverrideHostLb : public LoadBalancingPolicy {
       grpc_closure closure_;
     };
 
+    class SubchannelCreationRequester {
+     public:
+      SubchannelCreationRequester(RefCountedPtr<XdsOverrideHostLb> policy,
+                                  absl::string_view address)
+          : policy_(std::move(policy)), address_(address) {
+        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<SubchannelCreationRequester*>(arg);
+        self->policy_->work_serializer()->Run(
+            [self]() {
+              self->policy_->CreateSubchannelForAddress(self->address_);
+              delete self;
+            },
+            DEBUG_LOCATION);
+      }
+
+      RefCountedPtr<XdsOverrideHostLb> policy_;
+      std::string address_;
+      grpc_closure closure_;
+    };
+
     absl::optional<LoadBalancingPolicy::PickResult> PickOverridenHost(
         XdsOverrideHostAttribute* override_host_attr) const;
 
@@ -291,31 +398,45 @@ class XdsOverrideHostLb : public LoadBalancingPolicy {
                      RefCountedPtr<SubchannelPicker> picker) override;
   };
 
+  class IdleTimer : public InternallyRefCounted<IdleTimer> {
+   public:
+    IdleTimer(RefCountedPtr<XdsOverrideHostLb> policy, Duration duration);
+
+    void Orphan() override;
+
+   private:
+    void OnTimerLocked();
+
+    RefCountedPtr<XdsOverrideHostLb> policy_;
+    absl::optional<EventEngine::TaskHandle> timer_handle_;
+  };
+
   ~XdsOverrideHostLb() override;
 
   void ShutdownLocked() override;
 
+  void ResetState();
+  void ReportTransientFailure(absl::Status status);
+
   OrphanablePtr<LoadBalancingPolicy> CreateChildPolicyLocked(
       const ChannelArgs& args);
 
   void MaybeUpdatePickerLocked();
 
-  absl::StatusOr<EndpointAddressesList> UpdateAddressMap(
-      absl::StatusOr<EndpointAddressesList> endpoints);
+  void UpdateAddressMap(const EndpointAddressesIterator& endpoints);
 
   RefCountedPtr<SubchannelWrapper> AdoptSubchannel(
       const grpc_resolved_address& address,
       RefCountedPtr<SubchannelInterface> subchannel);
 
-  void UnsetSubchannel(absl::string_view key, SubchannelWrapper* subchannel);
+  void CreateSubchannelForAddress(absl::string_view address);
 
-  void OnSubchannelConnectivityStateChange(absl::string_view subchannel_key)
-      ABSL_NO_THREAD_SAFETY_ANALYSIS;  // Called from within the
-                                       // WorkSerializer and does not require
-                                       // additional synchronization
+  void CleanupSubchannels();
 
-  // Current config from the resolver.
-  RefCountedPtr<XdsOverrideHostLbConfig> config_;
+  // State from most recent resolver update.
+  ChannelArgs args_;
+  XdsHealthStatusSet override_host_status_set_;
+  Duration connection_idle_timeout_;
 
   // Internal state.
   bool shutting_down_ = false;
@@ -326,9 +447,12 @@ class XdsOverrideHostLb : public LoadBalancingPolicy {
   grpc_connectivity_state state_ = GRPC_CHANNEL_CONNECTING;
   absl::Status status_;
   RefCountedPtr<SubchannelPicker> picker_;
-  Mutex subchannel_map_mu_;
-  std::map<std::string, SubchannelEntry, std::less<>> subchannel_map_
-      ABSL_GUARDED_BY(subchannel_map_mu_);
+  Mutex mu_;
+  std::map<std::string, RefCountedPtr<SubchannelEntry>, std::less<>>
+      subchannel_map_ ABSL_GUARDED_BY(mu_);
+
+  // Timer handle for periodic subchannel sweep.
+  OrphanablePtr<IdleTimer> idle_timer_;
 };
 
 //
@@ -355,34 +479,36 @@ XdsOverrideHostLb::Picker::PickOverridenHost(
   auto cookie_address_list = override_host_attr->cookie_address_list();
   if (cookie_address_list.empty()) return absl::nullopt;
   // The cookie has an address list, so look through the addresses in order.
+  absl::string_view address_with_no_subchannel;
   RefCountedPtr<SubchannelWrapper> idle_subchannel;
   bool found_connecting = false;
   {
-    MutexLock lock(&policy_->subchannel_map_mu_);
+    MutexLock lock(&policy_->mu_);
     for (absl::string_view address : absl::StrSplit(cookie_address_list, ',')) {
-      RefCountedPtr<SubchannelWrapper> subchannel;
       auto it = policy_->subchannel_map_.find(address);
-      if (it != policy_->subchannel_map_.end()) {
-        subchannel = it->second.GetSubchannel()->RefIfNonZero();
-      }
-      if (subchannel == nullptr) {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
-          gpr_log(GPR_INFO, "Subchannel %s was not found",
-                  std::string(address).c_str());
-        }
-        continue;
-      }
+      if (it == policy_->subchannel_map_.end()) continue;
       if (!override_host_health_status_set_.Contains(
-              it->second.eds_health_status())) {
+              it->second->eds_health_status())) {
         if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
           gpr_log(GPR_INFO,
                   "Subchannel %s health status is not overridden (%s)",
                   std::string(address).c_str(),
-                  it->second.eds_health_status().ToString());
+                  it->second->eds_health_status().ToString());
         }
         continue;
       }
-      auto connectivity_state = subchannel->connectivity_state();
+      auto subchannel = it->second->GetSubchannelRef();
+      if (subchannel == nullptr) {
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+          gpr_log(GPR_INFO, "No subchannel for %s",
+                  std::string(address).c_str());
+        }
+        if (address_with_no_subchannel.empty()) {
+          address_with_no_subchannel = it->first;
+        }
+        continue;
+      }
+      auto connectivity_state = it->second->connectivity_state();
       if (connectivity_state == GRPC_CHANNEL_READY) {
         // Found a READY subchannel.  Pass back the actual address list
         // and return the subchannel.
@@ -390,7 +516,8 @@ XdsOverrideHostLb::Picker::PickOverridenHost(
           gpr_log(GPR_INFO, "Picker override found READY subchannel %s",
                   std::string(address).c_str());
         }
-        override_host_attr->set_actual_address_list(it->second.address_list());
+        it->second->set_last_used_time();
+        override_host_attr->set_actual_address_list(it->second->address_list());
         return PickResult::Complete(subchannel->wrapped_subchannel());
       } else if (connectivity_state == GRPC_CHANNEL_IDLE) {
         if (idle_subchannel == nullptr) idle_subchannel = std::move(subchannel);
@@ -417,7 +544,26 @@ XdsOverrideHostLb::Picker::PickOverridenHost(
     }
     return PickResult::Queue();
   }
-  // No READY, IDLE, or CONNECTING subchannels found.
+  // No READY, IDLE, or CONNECTING subchannels found.  If we found an
+  // entry that has no subchannel, then queue the pick and trigger
+  // creation of a subchannel for that entry.
+  if (!address_with_no_subchannel.empty()) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+      gpr_log(GPR_INFO, "Picker override found entry with no subchannel");
+    }
+    if (!IsWorkSerializerDispatchEnabled()) {
+      new SubchannelCreationRequester(policy_, address_with_no_subchannel);
+    } else {
+      policy_->work_serializer()->Run(
+          [policy = policy_,
+           address = std::string(address_with_no_subchannel)]() {
+            policy->CreateSubchannelForAddress(address);
+          },
+          DEBUG_LOCATION);
+    }
+    return PickResult::Queue();
+  }
+  // No entry found that was not in TRANSIENT_FAILURE.
   return absl::nullopt;
 }
 
@@ -444,15 +590,9 @@ LoadBalancingPolicy::PickResult XdsOverrideHostLb::Picker::Pick(PickArgs args) {
     // Populate the address list in the override host attribute so that
     // the StatefulSession filter can set the cookie.
     if (override_host_attr != nullptr) {
-      auto& key = wrapper->key();
-      if (key.has_value()) {
-        MutexLock lock(&policy_->subchannel_map_mu_);
-        auto it = policy_->subchannel_map_.find(*key);
-        if (it != policy_->subchannel_map_.end()) {  // Should always be true.
-          override_host_attr->set_actual_address_list(
-              it->second.address_list());
-        }
-      }
+      MutexLock lock(&wrapper->policy()->mu_);
+      wrapper->set_last_used_time();
+      override_host_attr->set_actual_address_list(wrapper->address_list());
     }
     // Unwrap the subchannel.
     complete_pick->subchannel = wrapper->wrapped_subchannel();
@@ -460,6 +600,56 @@ LoadBalancingPolicy::PickResult XdsOverrideHostLb::Picker::Pick(PickArgs args) {
   return result;
 }
 
+//
+// XdsOverrideHostLb::IdleTimer
+//
+
+XdsOverrideHostLb::IdleTimer::IdleTimer(RefCountedPtr<XdsOverrideHostLb> policy,
+                                        Duration duration)
+    : policy_(std::move(policy)) {
+  // Min time between timer runs is 5s so that we don't kill ourselves
+  // with lock contention and CPU usage due to sweeps over the map.
+  duration = std::max(duration, Duration::Seconds(5));
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+    gpr_log(GPR_INFO,
+            "[xds_override_host_lb %p] idle timer %p: subchannel cleanup "
+            "pass will run in %s",
+            policy_.get(), this, duration.ToString().c_str());
+  }
+  timer_handle_ = policy_->channel_control_helper()->GetEventEngine()->RunAfter(
+      duration, [self = RefAsSubclass<IdleTimer>()]() mutable {
+        ApplicationCallbackExecCtx callback_exec_ctx;
+        ExecCtx exec_ctx;
+        auto self_ptr = self.get();
+        self_ptr->policy_->work_serializer()->Run(
+            [self = std::move(self)]() { self->OnTimerLocked(); },
+            DEBUG_LOCATION);
+      });
+}
+
+void XdsOverrideHostLb::IdleTimer::Orphan() {
+  if (timer_handle_.has_value()) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+      gpr_log(GPR_INFO, "[xds_override_host_lb %p] idle timer %p: cancelling",
+              policy_.get(), this);
+    }
+    policy_->channel_control_helper()->GetEventEngine()->Cancel(*timer_handle_);
+    timer_handle_.reset();
+  }
+  Unref();
+}
+
+void XdsOverrideHostLb::IdleTimer::OnTimerLocked() {
+  if (timer_handle_.has_value()) {
+    timer_handle_.reset();
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+      gpr_log(GPR_INFO, "[xds_override_host_lb %p] idle timer %p: timer fired",
+              policy_.get(), this);
+    }
+    policy_->CleanupSubchannels();
+  }
+}
+
 //
 // XdsOverrideHostLb
 //
@@ -484,10 +674,22 @@ void XdsOverrideHostLb::ShutdownLocked() {
     gpr_log(GPR_INFO, "[xds_override_host_lb %p] shutting down", this);
   }
   shutting_down_ = true;
+  ResetState();
+}
+
+void XdsOverrideHostLb::ResetState() {
   {
-    MutexLock lock(&subchannel_map_mu_);
+    // Drop subchannel refs after releasing the lock to avoid deadlock.
+    std::vector<RefCountedPtr<SubchannelWrapper>> subchannel_refs_to_drop;
+    MutexLock lock(&mu_);
+    subchannel_refs_to_drop.reserve(subchannel_map_.size());
+    for (auto& p : subchannel_map_) {
+      p.second->UnsetSubchannel(&subchannel_refs_to_drop);
+    }
     subchannel_map_.clear();
   }
+  // Cancel timer, if any.
+  idle_timer_.reset();
   // Remove the child policy's interested_parties pollset_set from the
   // xDS policy.
   if (child_policy_ != nullptr) {
@@ -500,6 +702,18 @@ void XdsOverrideHostLb::ShutdownLocked() {
   picker_.reset();
 }
 
+void XdsOverrideHostLb::ReportTransientFailure(absl::Status status) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+    gpr_log(GPR_INFO,
+            "[xds_override_host_lb %p] reporting TRANSIENT_FAILURE: %s", this,
+            status.ToString().c_str());
+  }
+  ResetState();
+  channel_control_helper()->UpdateState(
+      GRPC_CHANNEL_TRANSIENT_FAILURE, status,
+      MakeRefCounted<TransientFailurePicker>(status));
+}
+
 void XdsOverrideHostLb::ExitIdleLocked() {
   if (child_policy_ != nullptr) child_policy_->ExitIdleLocked();
 }
@@ -508,29 +722,99 @@ void XdsOverrideHostLb::ResetBackoffLocked() {
   if (child_policy_ != nullptr) child_policy_->ResetBackoffLocked();
 }
 
+XdsHealthStatus GetEndpointHealthStatus(const EndpointAddresses& endpoint) {
+  return XdsHealthStatus(static_cast<XdsHealthStatus::HealthStatus>(
+      endpoint.args()
+          .GetInt(GRPC_ARG_XDS_HEALTH_STATUS)
+          .value_or(XdsHealthStatus::HealthStatus::kUnknown)));
+}
+
+// Wraps the endpoint iterator and filters out endpoints in state DRAINING.
+class ChildEndpointIterator : public EndpointAddressesIterator {
+ public:
+  explicit ChildEndpointIterator(
+      std::shared_ptr<EndpointAddressesIterator> parent_it)
+      : parent_it_(std::move(parent_it)) {}
+
+  void ForEach(absl::FunctionRef<void(const EndpointAddresses&)> callback)
+      const override {
+    parent_it_->ForEach([&](const EndpointAddresses& endpoint) {
+      XdsHealthStatus status = GetEndpointHealthStatus(endpoint);
+      if (status.status() != XdsHealthStatus::kDraining) {
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+          gpr_log(GPR_INFO,
+                  "[xds_override_host_lb %p] endpoint %s: not draining, "
+                  "passing to child",
+                  this, endpoint.ToString().c_str());
+        }
+        callback(endpoint);
+      }
+    });
+  }
+
+ private:
+  std::shared_ptr<EndpointAddressesIterator> parent_it_;
+};
+
 absl::Status XdsOverrideHostLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
-    gpr_log(GPR_INFO,
-            "[xds_override_host_lb %p] Received update with %" PRIuPTR
-            " addresses",
-            this, args.addresses.ok() ? args.addresses->size() : 0);
-  }
-  auto old_config = std::move(config_);
-  // Update config.
-  config_ = std::move(args.config);
-  if (config_ == nullptr) {
+    gpr_log(GPR_INFO, "[xds_override_host_lb %p] Received update", this);
+  }
+  // Grab new LB policy config.
+  if (args.config == nullptr) {
     return absl::InvalidArgumentError("Missing policy config");
   }
+  auto new_config = args.config.TakeAsSubclass<XdsOverrideHostLbConfig>();
+  // Get xDS config.
+  auto new_xds_config =
+      args.args.GetObjectRef<XdsDependencyManager::XdsConfig>();
+  if (new_xds_config == nullptr) {
+    // Should never happen.
+    absl::Status status = absl::InternalError(
+        "xDS config not passed to xds_cluster_impl LB policy");
+    ReportTransientFailure(status);
+    return status;
+  }
+  auto it = new_xds_config->clusters.find(new_config->cluster_name());
+  if (it == new_xds_config->clusters.end() || !it->second.ok() ||
+      it->second->cluster == nullptr) {
+    // Should never happen.
+    absl::Status status = absl::InternalError(absl::StrCat(
+        "xDS config has no entry for cluster ", new_config->cluster_name()));
+    ReportTransientFailure(status);
+    return status;
+  }
+  args_ = std::move(args.args);
+  override_host_status_set_ = it->second->cluster->override_host_statuses;
+  connection_idle_timeout_ = it->second->cluster->connection_idle_timeout;
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+    gpr_log(GPR_INFO,
+            "[xds_override_host_lb %p] override host status set: %s "
+            "connection idle timeout: %s",
+            this, override_host_status_set_.ToString().c_str(),
+            connection_idle_timeout_.ToString().c_str());
+  }
+  // Update address map and wrap endpoint iterator for child policy.
+  if (args.addresses.ok()) {
+    UpdateAddressMap(**args.addresses);
+    args.addresses =
+        std::make_shared<ChildEndpointIterator>(std::move(*args.addresses));
+  } else {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+      gpr_log(GPR_INFO, "[xds_override_host_lb %p] address error: %s", this,
+              args.addresses.status().ToString().c_str());
+    }
+  }
   // Create child policy if needed.
   if (child_policy_ == nullptr) {
     child_policy_ = CreateChildPolicyLocked(args.args);
   }
   // Update child policy.
   UpdateArgs update_args;
-  update_args.addresses = UpdateAddressMap(std::move(args.addresses));
+  update_args.addresses = std::move(args.addresses);
   update_args.resolution_note = std::move(args.resolution_note);
-  update_args.config = config_->child_config();
-  update_args.args = std::move(args.args);
+  update_args.config = new_config->child_config();
+  update_args.args = args_;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
     gpr_log(GPR_INFO,
             "[xds_override_host_lb %p] Updating child policy handler %p", this,
@@ -542,7 +826,7 @@ absl::Status XdsOverrideHostLb::UpdateLocked(UpdateArgs args) {
 void XdsOverrideHostLb::MaybeUpdatePickerLocked() {
   if (picker_ != nullptr) {
     auto xds_override_host_picker = MakeRefCounted<Picker>(
-        Ref(), picker_, config_->override_host_status_set());
+        RefAsSubclass<XdsOverrideHostLb>(), picker_, override_host_status_set_);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
       gpr_log(GPR_INFO,
               "[xds_override_host_lb %p] updating connectivity: state=%s "
@@ -560,8 +844,8 @@ OrphanablePtr<LoadBalancingPolicy> XdsOverrideHostLb::CreateChildPolicyLocked(
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.work_serializer = work_serializer();
   lb_policy_args.args = args;
-  lb_policy_args.channel_control_helper =
-      std::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
+  lb_policy_args.channel_control_helper = std::make_unique<Helper>(
+      RefAsSubclass<XdsOverrideHostLb>(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
                                          &grpc_lb_xds_override_host_trace);
@@ -578,18 +862,9 @@ OrphanablePtr<LoadBalancingPolicy> XdsOverrideHostLb::CreateChildPolicyLocked(
   return lb_policy;
 }
 
-absl::StatusOr<EndpointAddressesList> XdsOverrideHostLb::UpdateAddressMap(
-    absl::StatusOr<EndpointAddressesList> endpoints) {
-  if (!endpoints.ok()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
-      gpr_log(GPR_INFO, "[xds_override_host_lb %p] address error: %s", this,
-              endpoints.status().ToString().c_str());
-    }
-    return endpoints;
-  }
-  // Construct the list of addresses to pass to the child policy and a
-  // map of address info from which to update subchannel_map_.
-  EndpointAddressesList child_addresses;
+void XdsOverrideHostLb::UpdateAddressMap(
+    const EndpointAddressesIterator& endpoints) {
+  // Construct a map of address info from which to update subchannel_map_.
   struct AddressInfo {
     XdsHealthStatus eds_health_status;
     RefCountedStringValue address_list;
@@ -597,36 +872,31 @@ absl::StatusOr<EndpointAddressesList> XdsOverrideHostLb::UpdateAddressMap(
         : eds_health_status(status), address_list(std::move(addresses)) {}
   };
   std::map<const std::string, AddressInfo> addresses_for_map;
-  for (const auto& endpoint : *endpoints) {
+  endpoints.ForEach([&](const EndpointAddresses& endpoint) {
     XdsHealthStatus status = GetEndpointHealthStatus(endpoint);
-    if (status.status() != XdsHealthStatus::kDraining) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
-        gpr_log(GPR_INFO,
-                "[xds_override_host_lb %p] endpoint %s: not draining, "
-                "passing to child",
-                this, endpoint.ToString().c_str());
-      }
-      child_addresses.push_back(endpoint);
-    } else if (!config_->override_host_status_set().Contains(status)) {
-      // Skip draining hosts if not in the override status set.
+    // Skip draining hosts if not in the override status set.
+    if (status.status() == XdsHealthStatus::kDraining &&
+        !override_host_status_set_.Contains(status)) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
         gpr_log(GPR_INFO,
                 "[xds_override_host_lb %p] endpoint %s: draining but not in "
                 "override_host_status set -- ignoring",
                 this, endpoint.ToString().c_str());
       }
-      continue;
+      return;
     }
     std::vector<std::string> addresses;
     addresses.reserve(endpoint.addresses().size());
     for (const auto& address : endpoint.addresses()) {
       auto key = grpc_sockaddr_to_string(&address, /*normalize=*/false);
-      if (key.ok()) {
+      if (!key.ok()) {
         if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
           gpr_log(GPR_INFO,
-                  "[xds_override_host_lb %p] endpoint %s: adding map key %s",
-                  this, endpoint.ToString().c_str(), key->c_str());
+                  "[xds_override_host_lb %p] no key for endpoint address; "
+                  "not adding to map",
+                  this);
         }
+      } else {
         addresses.push_back(*std::move(key));
       }
     }
@@ -641,16 +911,22 @@ absl::StatusOr<EndpointAddressesList> XdsOverrideHostLb::UpdateAddressMap(
           std::piecewise_construct, std::forward_as_tuple(addresses[i]),
           std::forward_as_tuple(status, std::move(address_list)));
     }
-  }
+  });
   // Now grab the lock and update subchannel_map_ from addresses_for_map.
+  const Timestamp now = Timestamp::Now();
+  const Timestamp idle_threshold = now - connection_idle_timeout_;
+  Duration next_time = connection_idle_timeout_;
   {
-    MutexLock lock(&subchannel_map_mu_);
+    // Drop subchannel refs after releasing the lock to avoid deadlock.
+    std::vector<RefCountedPtr<SubchannelWrapper>> subchannel_refs_to_drop;
+    MutexLock lock(&mu_);
     for (auto it = subchannel_map_.begin(); it != subchannel_map_.end();) {
       if (addresses_for_map.find(it->first) == addresses_for_map.end()) {
         if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
           gpr_log(GPR_INFO, "[xds_override_host_lb %p] removing map key %s",
                   this, it->first.c_str());
         }
+        it->second->UnsetSubchannel(&subchannel_refs_to_drop);
         it = subchannel_map_.erase(it);
       } else {
         ++it;
@@ -665,70 +941,116 @@ absl::StatusOr<EndpointAddressesList> XdsOverrideHostLb::UpdateAddressMap(
           gpr_log(GPR_INFO, "[xds_override_host_lb %p] adding map key %s", this,
                   address.c_str());
         }
-        it = subchannel_map_
-                 .emplace(std::piecewise_construct,
-                          std::forward_as_tuple(address),
-                          std::forward_as_tuple(address_info.eds_health_status))
+        it = subchannel_map_.emplace(address, MakeRefCounted<SubchannelEntry>())
                  .first;
-      } else {
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
-          gpr_log(GPR_INFO,
-                  "[xds_override_host_lb %p] setting EDS health status for "
-                  "%s to %s",
-                  this, address.c_str(),
-                  address_info.eds_health_status.ToString());
-        }
-        it->second.SetEdsHealthStatus(address_info.eds_health_status);
       }
       if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
         gpr_log(GPR_INFO,
-                "[xds_override_host_lb %p] setting address list for %s to %s",
-                this, address.c_str(), address_info.address_list.c_str());
+                "[xds_override_host_lb %p] map key %s: setting "
+                "eds_health_status=%s address_list=%s",
+                this, address.c_str(),
+                address_info.eds_health_status.ToString(),
+                address_info.address_list.c_str());
+      }
+      it->second->set_eds_health_status(address_info.eds_health_status);
+      it->second->set_address_list(std::move(address_info.address_list));
+      // 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) {
+        const Duration next_time_for_entry =
+            it->second->last_used_time() + connection_idle_timeout_ - now;
+        next_time = std::min(next_time, next_time_for_entry);
       }
-      it->second.set_address_list(std::move(address_info.address_list));
     }
   }
-  return child_addresses;
+  idle_timer_ =
+      MakeOrphanable<IdleTimer>(RefAsSubclass<XdsOverrideHostLb>(), next_time);
 }
 
 RefCountedPtr<XdsOverrideHostLb::SubchannelWrapper>
 XdsOverrideHostLb::AdoptSubchannel(
     const grpc_resolved_address& address,
     RefCountedPtr<SubchannelInterface> subchannel) {
+  auto wrapper = MakeRefCounted<SubchannelWrapper>(
+      std::move(subchannel), RefAsSubclass<XdsOverrideHostLb>());
   auto key = grpc_sockaddr_to_string(&address, /*normalize=*/false);
-  auto wrapper =
-      MakeRefCounted<SubchannelWrapper>(std::move(subchannel), Ref());
   if (key.ok()) {
-    MutexLock lock(&subchannel_map_mu_);
+    // Drop ref to previously owned subchannel (if any) after releasing
+    // the lock.
+    RefCountedPtr<SubchannelWrapper> subchannel_ref_to_drop;
+    MutexLock lock(&mu_);
     auto it = subchannel_map_.find(*key);
     if (it != subchannel_map_.end()) {
-      wrapper->set_key(*key);
-      it->second.SetSubchannel(wrapper.get());
+      wrapper->set_subchannel_entry(it->second);
+      subchannel_ref_to_drop = it->second->SetUnownedSubchannel(wrapper.get());
     }
   }
   return wrapper;
 }
 
-void XdsOverrideHostLb::UnsetSubchannel(absl::string_view key,
-                                        SubchannelWrapper* subchannel) {
-  MutexLock lock(&subchannel_map_mu_);
-  auto it = subchannel_map_.find(key);
-  if (it != subchannel_map_.end()) {
-    if (subchannel == it->second.GetSubchannel()) {
-      it->second.UnsetSubchannel();
-    }
+void XdsOverrideHostLb::CreateSubchannelForAddress(absl::string_view address) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+    gpr_log(GPR_INFO,
+            "[xds_override_host_lb %p] creating owned subchannel for %s", this,
+            std::string(address).c_str());
+  }
+  auto addr = StringToSockaddr(address);
+  GPR_ASSERT(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.
+  auto subchannel = channel_control_helper()->CreateSubchannel(
+      *addr, /*per_address_args=*/ChannelArgs(), args_);
+  auto wrapper = MakeRefCounted<SubchannelWrapper>(
+      std::move(subchannel), RefAsSubclass<XdsOverrideHostLb>());
+  {
+    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;
+    wrapper->set_subchannel_entry(it->second);
+    it->second->SetOwnedSubchannel(std::move(wrapper));
   }
+  MaybeUpdatePickerLocked();
 }
 
-void XdsOverrideHostLb::OnSubchannelConnectivityStateChange(
-    absl::string_view subchannel_key) {
-  auto it = subchannel_map_.find(subchannel_key);
-  if (it == subchannel_map_.end()) {
-    return;
-  }
-  if (it->second.eds_health_status().status() == XdsHealthStatus::kDraining) {
-    MaybeUpdatePickerLocked();
+void XdsOverrideHostLb::CleanupSubchannels() {
+  const Timestamp now = Timestamp::Now();
+  const Timestamp idle_threshold = now - connection_idle_timeout_;
+  Duration next_time = connection_idle_timeout_;
+  std::vector<RefCountedPtr<SubchannelWrapper>> subchannel_refs_to_drop;
+  {
+    MutexLock lock(&mu_);
+    if (subchannel_map_.empty()) return;
+    for (const auto& p : subchannel_map_) {
+      if (p.second->last_used_time() <= idle_threshold) {
+        auto subchannel = p.second->TakeOwnedSubchannel();
+        if (subchannel != nullptr) {
+          if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+            gpr_log(GPR_INFO,
+                    "[xds_override_host_lb %p] dropping subchannel for %s",
+                    this, p.first.c_str());
+          }
+          subchannel_refs_to_drop.push_back(std::move(subchannel));
+        }
+      } else {
+        // Not dropping the subchannel.  Check the entry's last_used_time to
+        // determine the next time at which the timer needs to run.
+        const Duration next_time_for_entry =
+            p.second->last_used_time() + connection_idle_timeout_ - now;
+        next_time = std::min(next_time, next_time_for_entry);
+      }
+    }
   }
+  idle_timer_ =
+      MakeOrphanable<IdleTimer>(RefAsSubclass<XdsOverrideHostLb>(), next_time);
 }
 
 //
@@ -738,6 +1060,14 @@ void XdsOverrideHostLb::OnSubchannelConnectivityStateChange(
 RefCountedPtr<SubchannelInterface> XdsOverrideHostLb::Helper::CreateSubchannel(
     const grpc_resolved_address& address, const ChannelArgs& per_address_args,
     const ChannelArgs& args) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+    auto key = grpc_sockaddr_to_string(&address, /*normalize=*/false);
+    gpr_log(GPR_INFO,
+            "[xds_override_host_lb %p] creating subchannel for %s, "
+            "per_address_args=%s, args=%s",
+            this, key.value_or("<unknown>").c_str(),
+            per_address_args.ToString().c_str(), args.ToString().c_str());
+  }
   auto subchannel = parent()->channel_control_helper()->CreateSubchannel(
       address, per_address_args, args);
   return parent()->AdoptSubchannel(address, std::move(subchannel));
@@ -756,24 +1086,19 @@ void XdsOverrideHostLb::Helper::UpdateState(
 }
 
 //
-// XdsOverrideHostLb::SubchannelWrapper::SubchannelWrapper
+// XdsOverrideHostLb::SubchannelWrapper
 //
 
 XdsOverrideHostLb::SubchannelWrapper::SubchannelWrapper(
     RefCountedPtr<SubchannelInterface> subchannel,
     RefCountedPtr<XdsOverrideHostLb> policy)
     : DelegatingSubchannel(std::move(subchannel)), policy_(std::move(policy)) {
-  auto watcher = std::make_unique<ConnectivityStateWatcher>(WeakRef());
+  auto watcher = std::make_unique<ConnectivityStateWatcher>(
+      WeakRefAsSubclass<SubchannelWrapper>());
   watcher_ = watcher.get();
   wrapped_subchannel()->WatchConnectivityState(std::move(watcher));
 }
 
-XdsOverrideHostLb::SubchannelWrapper::~SubchannelWrapper() {
-  if (key_.has_value()) {
-    policy_->UnsetSubchannel(*key_, this);
-  }
-}
-
 void XdsOverrideHostLb::SubchannelWrapper::WatchConnectivityState(
     std::unique_ptr<ConnectivityStateWatcherInterface> watcher) {
   watchers_.insert(std::move(watcher));
@@ -787,9 +1112,45 @@ void XdsOverrideHostLb::SubchannelWrapper::CancelConnectivityStateWatch(
   }
 }
 
+void XdsOverrideHostLb::SubchannelWrapper::Orphan() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+    gpr_log(GPR_INFO,
+            "[xds_override_host_lb %p] subchannel wrapper %p orphaned",
+            policy_.get(), this);
+  }
+  if (!IsWorkSerializerDispatchEnabled()) {
+    wrapped_subchannel()->CancelConnectivityStateWatch(watcher_);
+    if (subchannel_entry_ != nullptr) {
+      MutexLock lock(&policy()->mu_);
+      subchannel_entry_->OnSubchannelWrapperOrphan(
+          this, policy()->connection_idle_timeout_);
+    }
+    return;
+  }
+  policy()->work_serializer()->Run(
+      [self = WeakRefAsSubclass<SubchannelWrapper>()]() {
+        self->wrapped_subchannel()->CancelConnectivityStateWatch(
+            self->watcher_);
+        if (self->subchannel_entry_ != nullptr) {
+          MutexLock lock(&self->policy()->mu_);
+          self->subchannel_entry_->OnSubchannelWrapperOrphan(
+              self.get(), self->policy()->connection_idle_timeout_);
+        }
+      },
+      DEBUG_LOCATION);
+}
+
 void XdsOverrideHostLb::SubchannelWrapper::UpdateConnectivityState(
     grpc_connectivity_state state, absl::Status status) {
-  connectivity_state_.store(state);
+  bool update_picker = false;
+  if (subchannel_entry_ != nullptr) {
+    MutexLock lock(&policy()->mu_);
+    if (subchannel_entry_->connectivity_state() != state) {
+      subchannel_entry_->set_connectivity_state(state);
+      update_picker = subchannel_entry_->HasOwnedSubchannel() &&
+                      subchannel_entry_->GetSubchannel() == this;
+    }
+  }
   // Sending connectivity state notifications to the watchers may cause the set
   // of watchers to change, so we can't be iterating over the set of watchers
   // while we send the notifications
@@ -803,41 +1164,94 @@ void XdsOverrideHostLb::SubchannelWrapper::UpdateConnectivityState(
       watcher->OnConnectivityStateChange(state, status);
     }
   }
-  if (key_.has_value()) {
-    policy_->OnSubchannelConnectivityStateChange(*key_);
-  }
+  if (update_picker) policy()->MaybeUpdatePickerLocked();
 }
 
-void XdsOverrideHostLb::SubchannelWrapper::Orphan() {
-  if (!IsWorkSerializerDispatchEnabled()) {
-    key_.reset();
-    wrapped_subchannel()->CancelConnectivityStateWatch(watcher_);
-    return;
-  }
-  WeakRefCountedPtr<SubchannelWrapper> self = WeakRef();
-  policy_->work_serializer()->Run(
-      [self = std::move(self)]() {
-        self->key_.reset();
-        self->wrapped_subchannel()->CancelConnectivityStateWatch(
-            self->watcher_);
+//
+// XdsOverrideHostLb::SubchannelEntry
+//
+
+RefCountedPtr<XdsOverrideHostLb::SubchannelWrapper>
+XdsOverrideHostLb::SubchannelEntry::SetUnownedSubchannel(
+    SubchannelWrapper* subchannel)
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+  auto owned_subchannel = TakeOwnedSubchannel();
+  subchannel_ = subchannel;
+  return owned_subchannel;
+}
+
+XdsOverrideHostLb::SubchannelWrapper*
+XdsOverrideHostLb::SubchannelEntry::GetSubchannel() const
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+  return Match(
+      subchannel_, [](SubchannelWrapper* subchannel) { return subchannel; },
+      [](const RefCountedPtr<SubchannelWrapper>& subchannel) {
+        return subchannel.get();
+      });
+}
+
+RefCountedPtr<XdsOverrideHostLb::SubchannelWrapper>
+XdsOverrideHostLb::SubchannelEntry::GetSubchannelRef() const
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+  auto* sc = GetSubchannel();
+  if (sc == nullptr) return nullptr;
+  return sc->RefIfNonZero().TakeAsSubclass<SubchannelWrapper>();
+}
+
+RefCountedPtr<XdsOverrideHostLb::SubchannelWrapper>
+XdsOverrideHostLb::SubchannelEntry::TakeOwnedSubchannel()
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+  return MatchMutable(
+      &subchannel_,
+      [](SubchannelWrapper**) -> RefCountedPtr<SubchannelWrapper> {
+        return nullptr;
       },
-      DEBUG_LOCATION);
+      [](RefCountedPtr<SubchannelWrapper>* subchannel) {
+        return std::move(*subchannel);
+      });
 }
 
-grpc_pollset_set* XdsOverrideHostLb::SubchannelWrapper::
-    ConnectivityStateWatcher::interested_parties() {
-  return subchannel_->policy_->interested_parties();
+void XdsOverrideHostLb::SubchannelEntry::UnsetSubchannel(
+    std::vector<RefCountedPtr<SubchannelWrapper>>* owned_subchannels)
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+  auto subchannel = TakeOwnedSubchannel();
+  if (subchannel != nullptr) {
+    owned_subchannels->push_back(std::move(subchannel));
+  }
+  subchannel_ = nullptr;
 }
 
-void XdsOverrideHostLb::SubchannelWrapper::ConnectivityStateWatcher::
-    OnConnectivityStateChange(grpc_connectivity_state state,
-                              absl::Status status) {
-  subchannel_->UpdateConnectivityState(state, status);
+void XdsOverrideHostLb::SubchannelEntry::OnSubchannelWrapperOrphan(
+    SubchannelWrapper* wrapper, Duration connection_idle_timeout)
+    ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
+  auto* subchannel = GetSubchannel();
+  if (subchannel != wrapper) return;
+  if (last_used_time_ < (Timestamp::Now() - connection_idle_timeout)) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+      gpr_log(GPR_INFO,
+              "[xds_override_host_lb] removing unowned subchannel wrapper %p",
+              subchannel);
+    }
+    subchannel_ = nullptr;
+  } else {
+    // The subchannel is being released by the child policy, but it
+    // is still within its idle timeout, so we make a new copy of
+    // the wrapper with the same underlying subchannel, and we hold
+    // our own ref to it.
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_override_host_trace)) {
+      gpr_log(GPR_INFO,
+              "[xds_override_host_lb] subchannel wrapper %p: cloning "
+              "to gain ownership",
+              subchannel);
+    }
+    subchannel_ = wrapper->Clone();
+  }
 }
 
 //
 // factory
 //
+
 class XdsOverrideHostLbFactory : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
@@ -864,57 +1278,34 @@ void RegisterXdsOverrideHostLbPolicy(CoreConfiguration::Builder* builder) {
       std::make_unique<XdsOverrideHostLbFactory>());
 }
 
+//
 // XdsOverrideHostLbConfig
+//
 
 const JsonLoaderInterface* XdsOverrideHostLbConfig::JsonLoader(
     const JsonArgs&) {
   static const auto kJsonLoader =
       JsonObjectLoader<XdsOverrideHostLbConfig>()
           // Child policy config is parsed in JsonPostLoad
+          .Field("clusterName", &XdsOverrideHostLbConfig::cluster_name_)
           .Finish();
   return kJsonLoader;
 }
 
-void XdsOverrideHostLbConfig::JsonPostLoad(const Json& json,
-                                           const JsonArgs& args,
+void XdsOverrideHostLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
                                            ValidationErrors* errors) {
-  {
-    ValidationErrors::ScopedField field(errors, ".childPolicy");
-    auto it = json.object().find("childPolicy");
-    if (it == json.object().end()) {
-      errors->AddError("field not present");
-    } else {
-      auto child_policy_config = CoreConfiguration::Get()
-                                     .lb_policy_registry()
-                                     .ParseLoadBalancingConfig(it->second);
-      if (!child_policy_config.ok()) {
-        errors->AddError(child_policy_config.status().message());
-      } else {
-        child_config_ = std::move(*child_policy_config);
-      }
-    }
-  }
-  {
-    ValidationErrors::ScopedField field(errors, ".overrideHostStatus");
-    auto host_status_list = LoadJsonObjectField<std::vector<std::string>>(
-        json.object(), args, "overrideHostStatus", errors,
-        /*required=*/false);
-    if (host_status_list.has_value()) {
-      for (size_t i = 0; i < host_status_list->size(); ++i) {
-        const std::string& host_status = (*host_status_list)[i];
-        auto status = XdsHealthStatus::FromString(host_status);
-        if (!status.has_value()) {
-          ValidationErrors::ScopedField field(errors,
-                                              absl::StrCat("[", i, "]"));
-          errors->AddError("invalid host status");
-        } else {
-          override_host_status_set_.Add(*status);
-        }
-      }
+  ValidationErrors::ScopedField field(errors, ".childPolicy");
+  auto it = json.object().find("childPolicy");
+  if (it == json.object().end()) {
+    errors->AddError("field not present");
+  } else {
+    auto child_policy_config =
+        CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
+            it->second);
+    if (!child_policy_config.ok()) {
+      errors->AddError(child_policy_config.status().message());
     } else {
-      override_host_status_set_ = XdsHealthStatusSet(
-          {XdsHealthStatus(XdsHealthStatus::HealthStatus::kHealthy),
-           XdsHealthStatus(XdsHealthStatus::HealthStatus::kUnknown)});
+      child_config_ = std::move(*child_policy_config);
     }
   }
 }