grpc 1.49.1 → 1.50.0.pre1

data/src/core/ext/filters/client_channel/resolver/polling_resolver.cc

@@ -20,10 +20,13 @@
 
 #include <inttypes.h>
 
+#include <functional>
 #include <utility>
+#include <vector>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 
@@ -36,6 +39,7 @@
 #include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
@@ -69,7 +73,16 @@ void PollingResolver::StartLocked() { MaybeStartResolvingLocked(); }
 
 void PollingResolver::RequestReresolutionLocked() {
   if (request_ == nullptr) {
-    MaybeStartResolvingLocked();
+    // If we're still waiting for a result-health callback from the last
+    // result we reported, don't trigger the re-resolution until we get
+    // that callback.
+    if (result_status_state_ ==
+        ResultStatusState::kResultHealthCallbackPending) {
+      result_status_state_ =
+          ResultStatusState::kReresolutionRequestedWhileCallbackWasPending;
+    } else {
+      MaybeStartResolvingLocked();
+    }
   }
 }
 
@@ -126,44 +139,78 @@ void PollingResolver::OnRequestCompleteLocked(Result result) {
   }
   request_.reset();
   if (!shutdown_) {
-    if (result.service_config.ok() && result.addresses.ok()) {
-      // Reset backoff state so that we start from the beginning when the
-      // next request gets triggered.
-      backoff_.Reset();
-    } else {
-      if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-        gpr_log(GPR_INFO,
-                "[polling resolver %p] resolution failed (will retry): "
-                "address status \"%s\"; service config status \"%s\"",
-                this, result.addresses.status().ToString().c_str(),
-                result.service_config.status().ToString().c_str());
-      }
-      // Set up for retry.
-      // InvalidateNow to avoid getting stuck re-initializing this timer
-      // in a loop while draining the currently-held WorkSerializer.
-      // Also see https://github.com/grpc/grpc/issues/26079.
-      ExecCtx::Get()->InvalidateNow();
-      Timestamp next_try = backoff_.NextAttemptTime();
-      Duration timeout = next_try - ExecCtx::Get()->Now();
-      GPR_ASSERT(!have_next_resolution_timer_);
-      have_next_resolution_timer_ = true;
-      if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
-        if (timeout > Duration::Zero()) {
-          gpr_log(GPR_INFO, "[polling resolver %p] retrying in %" PRId64 " ms",
-                  this, timeout.millis());
-        } else {
-          gpr_log(GPR_INFO, "[polling resolver %p] retrying immediately", this);
-        }
-      }
-      Ref(DEBUG_LOCATION, "next_resolution_timer").release();
-      GRPC_CLOSURE_INIT(&on_next_resolution_, OnNextResolution, this, nullptr);
-      grpc_timer_init(&next_resolution_timer_, next_try, &on_next_resolution_);
+    if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+      gpr_log(GPR_INFO,
+              "[polling resolver %p] returning result: "
+              "addresses=%s, service_config=%s",
+              this,
+              result.addresses.ok()
+                  ? absl::StrCat("<", result.addresses->size(), " addresses>")
+                        .c_str()
+                  : result.addresses.status().ToString().c_str(),
+              result.service_config.ok()
+                  ? (*result.service_config == nullptr
+                         ? "<null>"
+                         : std::string((*result.service_config)->json_string())
+                               .c_str())
+                  : result.service_config.status().ToString().c_str());
     }
+    GPR_ASSERT(result.result_health_callback == nullptr);
+    RefCountedPtr<PollingResolver> self =
+        Ref(DEBUG_LOCATION, "result_health_callback");
+    result.result_health_callback = [self =
+                                         std::move(self)](absl::Status status) {
+      self->GetResultStatus(std::move(status));
+    };
+    result_status_state_ = ResultStatusState::kResultHealthCallbackPending;
     result_handler_->ReportResult(std::move(result));
   }
   Unref(DEBUG_LOCATION, "OnRequestComplete");
 }
 
+void PollingResolver::GetResultStatus(absl::Status status) {
+  if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+    gpr_log(GPR_INFO, "[polling resolver %p] result status from channel: %s",
+            this, status.ToString().c_str());
+  }
+  if (status.ok()) {
+    // Reset backoff state so that we start from the beginning when the
+    // next request gets triggered.
+    backoff_.Reset();
+    // If a re-resolution attempt was requested while the result-status
+    // callback was pending, trigger a new request now.
+    if (std::exchange(result_status_state_, ResultStatusState::kNone) ==
+        ResultStatusState::kReresolutionRequestedWhileCallbackWasPending) {
+      MaybeStartResolvingLocked();
+    }
+  } else {
+    // Set up for retry.
+    // InvalidateNow to avoid getting stuck re-initializing this timer
+    // in a loop while draining the currently-held WorkSerializer.
+    // Also see https://github.com/grpc/grpc/issues/26079.
+    ExecCtx::Get()->InvalidateNow();
+    Timestamp next_try = backoff_.NextAttemptTime();
+    Duration timeout = next_try - Timestamp::Now();
+    GPR_ASSERT(!have_next_resolution_timer_);
+    have_next_resolution_timer_ = true;
+    if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
+      if (timeout > Duration::Zero()) {
+        gpr_log(GPR_INFO, "[polling resolver %p] retrying in %" PRId64 " ms",
+                this, timeout.millis());
+      } else {
+        gpr_log(GPR_INFO, "[polling resolver %p] retrying immediately", this);
+      }
+    }
+    Ref(DEBUG_LOCATION, "next_resolution_timer").release();
+    GRPC_CLOSURE_INIT(&on_next_resolution_, OnNextResolution, this, nullptr);
+    grpc_timer_init(&next_resolution_timer_, next_try, &on_next_resolution_);
+    // Reset result_status_state_.  Note that even if re-resolution was
+    // requested while the result-health callback was pending, we can
+    // ignore it here, because we are in backoff to re-resolve anyway.
+    result_status_state_ = ResultStatusState::kNone;
+  }
+}
+
 void PollingResolver::MaybeStartResolvingLocked() {
   // If there is an existing timer, the time it fires is the earliest time we
   // can start the next resolution.
@@ -176,11 +223,11 @@ void PollingResolver::MaybeStartResolvingLocked() {
     const Timestamp earliest_next_resolution =
         *last_resolution_timestamp_ + min_time_between_resolutions_;
     const Duration time_until_next_resolution =
-        earliest_next_resolution - ExecCtx::Get()->Now();
+        earliest_next_resolution - Timestamp::Now();
     if (time_until_next_resolution > Duration::Zero()) {
       if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
         const Duration last_resolution_ago =
-            ExecCtx::Get()->Now() - *last_resolution_timestamp_;
+            Timestamp::Now() - *last_resolution_timestamp_;
         gpr_log(GPR_INFO,
                 "[polling resolver %p] in cooldown from last resolution "
                 "(from %" PRId64 " ms ago); will resolve again in %" PRId64
@@ -192,7 +239,7 @@ void PollingResolver::MaybeStartResolvingLocked() {
       Ref(DEBUG_LOCATION, "next_resolution_timer_cooldown").release();
       GRPC_CLOSURE_INIT(&on_next_resolution_, OnNextResolution, this, nullptr);
       grpc_timer_init(&next_resolution_timer_,
-                      ExecCtx::Get()->Now() + time_until_next_resolution,
+                      Timestamp::Now() + time_until_next_resolution,
                       &on_next_resolution_);
       return;
     }
@@ -202,7 +249,7 @@ void PollingResolver::MaybeStartResolvingLocked() {
 
 void PollingResolver::StartResolvingLocked() {
   request_ = StartRequest();
-  last_resolution_timestamp_ = ExecCtx::Get()->Now();
+  last_resolution_timestamp_ = Timestamp::Now();
   if (GPR_UNLIKELY(tracer_ != nullptr && tracer_->enabled())) {
     gpr_log(GPR_INFO, "[polling resolver %p] starting resolution, request_=%p",
             this, request_.get());

data/src/core/ext/filters/client_channel/resolver/polling_resolver.h

@@ -22,6 +22,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/status/status.h"
 #include "absl/types/optional.h"
 
 #include "src/core/lib/backoff/backoff.h"
@@ -77,6 +78,8 @@ class PollingResolver : public Resolver {
 
   void OnRequestCompleteLocked(Result result);
 
+  void GetResultStatus(absl::Status status);
+
   static void OnNextResolution(void* arg, grpc_error_handle error);
   void OnNextResolutionLocked(grpc_error_handle error);
 
@@ -105,6 +108,14 @@ class PollingResolver : public Resolver {
   absl::optional<Timestamp> last_resolution_timestamp_;
   /// retry backoff state
   BackOff backoff_;
+  /// state for handling interactions between re-resolution requests and
+  /// result health callbacks
+  enum class ResultStatusState {
+    kNone,
+    kResultHealthCallbackPending,
+    kReresolutionRequestedWhileCallbackWasPending,
+  };
+  ResultStatusState result_status_state_ = ResultStatusState::kNone;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/resolver/sockaddr/sockaddr_resolver.cc

@@ -20,6 +20,7 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "absl/memory/memory.h"
 #include "absl/status/statusor.h"

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -56,6 +56,7 @@
 #include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
+#include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client.h"
 #include "src/core/ext/xds/xds_client_grpc.h"
 #include "src/core/ext/xds/xds_http_filters.h"
@@ -813,7 +814,8 @@ void XdsResolver::StartLocked() {
   if (!uri_.authority().empty()) {
     // target_uri.authority is set case
     const auto* authority_config =
-        xds_client_->bootstrap().LookupAuthority(uri_.authority());
+        static_cast<const GrpcXdsBootstrap::GrpcAuthority*>(
+            xds_client_->bootstrap().LookupAuthority(uri_.authority()));
     if (authority_config == nullptr) {
       absl::Status status = absl::UnavailableError(
           absl::StrCat("Invalid target URI -- authority not found for ",
@@ -826,7 +828,7 @@ void XdsResolver::StartLocked() {
       return;
     }
     std::string name_template =
-        authority_config->client_listener_resource_name_template;
+        authority_config->client_listener_resource_name_template();
     if (name_template.empty()) {
       name_template = absl::StrCat(
           "xdstp://", URI::PercentEncodeAuthority(uri_.authority()),
@@ -838,7 +840,7 @@ void XdsResolver::StartLocked() {
   } else {
     // target_uri.authority not set
     absl::string_view name_template =
-        xds_client_->bootstrap()
+        static_cast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
             .client_default_listener_resource_name_template();
     if (name_template.empty()) {
       name_template = "%s";

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

@@ -85,12 +85,13 @@ absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
 ClientChannelServiceConfigParser::ParseGlobalParams(const ChannelArgs& /*args*/,
                                                     const Json& json) {
   std::vector<grpc_error_handle> error_list;
+  const auto& lb_policy_registry =
+      CoreConfiguration::Get().lb_policy_registry();
   // Parse LB config.
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config;
   auto it = json.object_value().find("loadBalancingConfig");
   if (it != json.object_value().end()) {
-    auto config =
-        LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(it->second);
+    auto config = lb_policy_registry.ParseLoadBalancingConfig(it->second);
     if (!config.ok()) {
       error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
           "field:loadBalancingConfig error:", config.status().message())));
@@ -111,8 +112,8 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const ChannelArgs& /*args*/,
         lb_policy_name[i] = tolower(lb_policy_name[i]);
       }
       bool requires_config = false;
-      if (!LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
-              lb_policy_name.c_str(), &requires_config)) {
+      if (!lb_policy_registry.LoadBalancingPolicyExists(lb_policy_name.c_str(),
+                                                        &requires_config)) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             "field:loadBalancingPolicy error:Unknown lb policy"));
       } else if (requires_config) {

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

@@ -33,7 +33,6 @@
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
-#include "absl/utility/utility.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
@@ -351,7 +350,11 @@ class RetryFilter::CallData {
       // cancel_stream op.
       static void OnCompleteForCancelOp(void* arg, grpc_error_handle error);
 
-      RefCountedPtr<CallAttempt> call_attempt_;
+      // This DOES hold a ref, but it cannot be a RefCountedPtr<>, because
+      // our dtor unrefs the owning call, which may delete the arena in
+      // which we are allocated, which means that running the dtor of any
+      // data members after that would cause a crash.
+      CallAttempt* call_attempt_;
       // The batch to use in the LB call.
       // Its payload field points to CallAttempt::batch_payload_.
       grpc_transport_stream_op_batch batch_;
@@ -722,8 +725,7 @@ RetryFilter::CallData::CallAttempt::CallAttempt(CallData* calld,
   if (calld->retry_policy_ != nullptr &&
       calld->retry_policy_->per_attempt_recv_timeout().has_value()) {
     Timestamp per_attempt_recv_deadline =
-        ExecCtx::Get()->Now() +
-        *calld->retry_policy_->per_attempt_recv_timeout();
+        Timestamp::Now() + *calld->retry_policy_->per_attempt_recv_timeout();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
       gpr_log(GPR_INFO,
               "chand=%p calld=%p attempt=%p: per-attempt timeout in %" PRId64
@@ -1330,11 +1332,11 @@ RetryFilter::CallData::CallAttempt::BatchData::BatchData(
     : RefCounted(
           GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace) ? "BatchData" : nullptr,
           refcount),
-      call_attempt_(std::move(attempt)) {
+      call_attempt_(attempt.release()) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     gpr_log(GPR_INFO, "chand=%p calld=%p attempt=%p: creating batch %p",
-            call_attempt_->calld_->chand_, call_attempt_->calld_,
-            call_attempt_.get(), this);
+            call_attempt_->calld_->chand_, call_attempt_->calld_, call_attempt_,
+            this);
   }
   // We hold a ref to the call stack for every batch sent on a call attempt.
   // This is because some batches on the call attempt may not complete
@@ -1354,11 +1356,12 @@ RetryFilter::CallData::CallAttempt::BatchData::BatchData(
 RetryFilter::CallData::CallAttempt::BatchData::~BatchData() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     gpr_log(GPR_INFO, "chand=%p calld=%p attempt=%p: destroying batch %p",
-            call_attempt_->calld_->chand_, call_attempt_->calld_,
-            call_attempt_.get(), this);
+            call_attempt_->calld_->chand_, call_attempt_->calld_, call_attempt_,
+            this);
   }
-  GRPC_CALL_STACK_UNREF(call_attempt_->calld_->owning_call_, "Retry BatchData");
-  call_attempt_.reset(DEBUG_LOCATION, "~BatchData");
+  CallAttempt* call_attempt = std::exchange(call_attempt_, nullptr);
+  GRPC_CALL_STACK_UNREF(call_attempt->calld_->owning_call_, "Retry BatchData");
+  call_attempt->Unref(DEBUG_LOCATION, "~BatchData");
 }
 
 void RetryFilter::CallData::CallAttempt::BatchData::
@@ -1422,7 +1425,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::
 void RetryFilter::CallData::CallAttempt::BatchData::RecvInitialMetadataReady(
     void* arg, grpc_error_handle error) {
   RefCountedPtr<BatchData> batch_data(static_cast<BatchData*>(arg));
-  CallAttempt* call_attempt = batch_data->call_attempt_.get();
+  CallAttempt* call_attempt = batch_data->call_attempt_;
   CallData* calld = call_attempt->calld_;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     gpr_log(GPR_INFO,
@@ -1524,7 +1527,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::
 void RetryFilter::CallData::CallAttempt::BatchData::RecvMessageReady(
     void* arg, grpc_error_handle error) {
   RefCountedPtr<BatchData> batch_data(static_cast<BatchData*>(arg));
-  CallAttempt* call_attempt = batch_data->call_attempt_.get();
+  CallAttempt* call_attempt = batch_data->call_attempt_;
   CallData* calld = call_attempt->calld_;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     gpr_log(GPR_INFO,
@@ -1722,15 +1725,8 @@ void RetryFilter::CallData::CallAttempt::BatchData::RunClosuresForCompletedCall(
 
 void RetryFilter::CallData::CallAttempt::BatchData::RecvTrailingMetadataReady(
     void* arg, grpc_error_handle error) {
-  // Add a ref to the outer call stack. This works around a TSAN reported
-  // failure that we do not understand, but since we expect the lifetime of
-  // this code to be relatively short we think it's OK to work around for now.
-  // TSAN failure:
-  // https://source.cloud.google.com/results/invocations/5b122974-4977-4862-beb1-dc1af9fbbd1d/targets/%2F%2Ftest%2Fcore%2Fend2end:h2_census_test@max_concurrent_streams@poller%3Dpoll/log
-  RefCountedPtr<grpc_call_stack> owning_call_stack =
-      static_cast<BatchData*>(arg)->call_attempt_->calld_->owning_call_->Ref();
   RefCountedPtr<BatchData> batch_data(static_cast<BatchData*>(arg));
-  CallAttempt* call_attempt = batch_data->call_attempt_.get();
+  CallAttempt* call_attempt = batch_data->call_attempt_;
   CallData* calld = call_attempt->calld_;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     gpr_log(GPR_INFO,
@@ -1886,7 +1882,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::
       gpr_log(GPR_INFO,
               "chand=%p calld=%p attempt=%p: starting next batch for pending "
               "send op(s)",
-              calld->chand_, calld, call_attempt_.get());
+              calld->chand_, calld, call_attempt_);
     }
     call_attempt_->AddRetriableBatches(closures);
   }
@@ -1895,7 +1891,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::
 void RetryFilter::CallData::CallAttempt::BatchData::OnComplete(
     void* arg, grpc_error_handle error) {
   RefCountedPtr<BatchData> batch_data(static_cast<BatchData*>(arg));
-  CallAttempt* call_attempt = batch_data->call_attempt_.get();
+  CallAttempt* call_attempt = batch_data->call_attempt_;
   CallData* calld = call_attempt->calld_;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     gpr_log(GPR_INFO,
@@ -1971,7 +1967,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::OnComplete(
 void RetryFilter::CallData::CallAttempt::BatchData::OnCompleteForCancelOp(
     void* arg, grpc_error_handle error) {
   RefCountedPtr<BatchData> batch_data(static_cast<BatchData*>(arg));
-  CallAttempt* call_attempt = batch_data->call_attempt_.get();
+  CallAttempt* call_attempt = batch_data->call_attempt_;
   CallData* calld = call_attempt->calld_;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     gpr_log(GPR_INFO,
@@ -2022,7 +2018,7 @@ void RetryFilter::CallData::CallAttempt::BatchData::
         GPR_INFO,
         "chand=%p calld=%p attempt=%p: starting calld->send_messages[%" PRIuPTR
         "]",
-        calld->chand_, calld, call_attempt_.get(),
+        calld->chand_, calld, call_attempt_,
         call_attempt_->started_send_message_count_);
   }
   CachedSendMessage cache =
@@ -2367,7 +2363,7 @@ void RetryFilter::CallData::MaybeCacheSendOpsForBatch(PendingBatch* pending) {
   // Set up cache for send_message ops.
   if (batch->send_message) {
     SliceBuffer* cache = arena_->New<SliceBuffer>(std::move(
-        *absl::exchange(batch->payload->send_message.send_message, nullptr)));
+        *std::exchange(batch->payload->send_message.send_message, nullptr)));
     send_messages_.push_back({cache, batch->payload->send_message.flags});
   }
   // Save metadata batch for send_trailing_metadata ops.
@@ -2394,7 +2390,7 @@ void RetryFilter::CallData::FreeCachedSendMessage(size_t idx) {
               "chand=%p calld=%p: destroying send_messages[%" PRIuPTR "]",
               chand_, this, idx);
     }
-    Destruct(absl::exchange(send_messages_[idx].slices, nullptr));
+    Destruct(std::exchange(send_messages_[idx].slices, nullptr));
   }
 }
 
@@ -2607,7 +2603,7 @@ void RetryFilter::CallData::StartRetryTimer(
   Timestamp next_attempt_time;
   if (server_pushback.has_value()) {
     GPR_ASSERT(*server_pushback >= Duration::Zero());
-    next_attempt_time = ExecCtx::Get()->Now() + *server_pushback;
+    next_attempt_time = Timestamp::Now() + *server_pushback;
     retry_backoff_.Reset();
   } else {
     next_attempt_time = retry_backoff_.NextAttemptTime();
@@ -2615,7 +2611,7 @@ void RetryFilter::CallData::StartRetryTimer(
   if (GRPC_TRACE_FLAG_ENABLED(grpc_retry_trace)) {
     gpr_log(GPR_INFO,
             "chand=%p calld=%p: retrying failed call in %" PRId64 " ms", chand_,
-            this, (next_attempt_time - ExecCtx::Get()->Now()).millis());
+            this, (next_attempt_time - Timestamp::Now()).millis());
   }
   // Schedule retry after computed delay.
   GRPC_CLOSURE_INIT(&retry_closure_, OnRetryTimer, this, nullptr);

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

@@ -27,15 +27,16 @@
 #include <utility>
 
 #include "absl/status/statusor.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
-#include <grpc/grpc.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/health/health_check_client.h"
-#include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
 #include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
@@ -55,18 +56,15 @@
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/surface/init_internally.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
 
-// Strong and weak refs.
-#define INTERNAL_REF_BITS 16
-#define STRONG_REF_MASK (~(gpr_atm)((1 << INTERNAL_REF_BITS) - 1))
-
 // Backoff parameters.
 #define GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER 1.6
@@ -175,7 +173,6 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
 
 void SubchannelCall::StartTransportStreamOpBatch(
     grpc_transport_stream_op_batch* batch) {
-  GPR_TIMER_SCOPE("subchannel_call_process_op", 0);
   MaybeInterceptRecvTrailingMetadata(batch);
   grpc_call_stack* call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(this);
   grpc_call_element* top_elem = grpc_call_stack_element(call_stack, 0);
@@ -214,7 +211,6 @@ void SubchannelCall::Unref(const DebugLocation& /*location*/,
 }
 
 void SubchannelCall::Destroy(void* arg, grpc_error_handle /*error*/) {
-  GPR_TIMER_SCOPE("subchannel_call_destroy", 0);
   SubchannelCall* self = static_cast<SubchannelCall*>(arg);
   // Keep some members before destroying the subchannel call.
   grpc_closure* after_call_stack_destroy = self->after_call_stack_destroy_;
@@ -640,13 +636,15 @@ Subchannel::Subchannel(SubchannelKey key,
   // before the last subchannel destruction, then there maybe race conditions
   // triggering segmentation faults. To prevent this issue, we call a grpc_init
   // here and a grpc_shutdown in the subchannel destructor.
-  grpc_init();
+  InitInternally();
   GRPC_STATS_INC_CLIENT_SUBCHANNELS_CREATED();
   GRPC_CLOSURE_INIT(&on_connecting_finished_, OnConnectingFinished, this,
                     grpc_schedule_on_exec_ctx);
   // Check proxy mapper to determine address to connect to and channel
   // args to use.
-  address_for_connect_ = ProxyMapperRegistry::MapAddress(key_.address(), &args_)
+  address_for_connect_ = CoreConfiguration::Get()
+                             .proxy_mapper_registry()
+                             .MapAddress(key_.address(), &args_)
                              .value_or(key_.address());
   // Initialize channelz.
   const bool channelz_enabled = args_.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
@@ -676,7 +674,7 @@ Subchannel::~Subchannel() {
   connector_.reset();
   grpc_pollset_set_destroy(pollset_set_);
   // grpc_shutdown is called here because grpc_init is called in the ctor.
-  grpc_shutdown();
+  ShutdownInternally();
 }
 
 RefCountedPtr<Subchannel> Subchannel::Create(
@@ -769,7 +767,7 @@ void Subchannel::ResetBackoff() {
       GetDefaultEventEngine()->Cancel(retry_timer_handle_)) {
     OnRetryTimerLocked();
   } else if (state_ == GRPC_CHANNEL_CONNECTING) {
-    next_attempt_time_ = ExecCtx::Get()->Now();
+    next_attempt_time_ = Timestamp::Now();
   }
 }
 
@@ -788,27 +786,20 @@ void Subchannel::Orphan() {
   health_watcher_map_.ShutdownLocked();
 }
 
-void Subchannel::AddDataProducer(DataProducerInterface* data_producer) {
+void Subchannel::GetOrAddDataProducer(
+    UniqueTypeName type,
+    std::function<void(DataProducerInterface**)> get_or_add) {
   MutexLock lock(&mu_);
-  auto& entry = data_producer_map_[data_producer->type()];
-  GPR_ASSERT(entry == nullptr);
-  entry = data_producer;
+  auto it = data_producer_map_.emplace(type, nullptr).first;
+  get_or_add(&it->second);
 }
 
 void Subchannel::RemoveDataProducer(DataProducerInterface* data_producer) {
   MutexLock lock(&mu_);
   auto it = data_producer_map_.find(data_producer->type());
-  GPR_ASSERT(it != data_producer_map_.end());
-  GPR_ASSERT(it->second == data_producer);
-  data_producer_map_.erase(it);
-}
-
-Subchannel::DataProducerInterface* Subchannel::GetDataProducer(
-    UniqueTypeName type) {
-  MutexLock lock(&mu_);
-  auto it = data_producer_map_.find(type);
-  if (it == data_producer_map_.end()) return nullptr;
-  return it->second;
+  if (it != data_producer_map_.end() && it->second == data_producer) {
+    data_producer_map_.erase(it);
+  }
 }
 
 namespace {
@@ -838,7 +829,21 @@ const char* SubchannelConnectivityStateChangeString(
 void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
                                             const absl::Status& status) {
   state_ = state;
-  status_ = status;
+  if (status.ok()) {
+    status_ = status;
+  } else {
+    // Augment status message to include IP address.
+    status_ = absl::Status(status.code(),
+                           absl::StrCat(grpc_sockaddr_to_uri(&key_.address())
+                                            .value_or("<unknown address type>"),
+                                        ": ", status.message()));
+    status.ForEachPayload(
+        [this](absl::string_view key, const absl::Cord& value)
+        // Want to use ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_) here,
+        // but that won't work, because we can't pass the lock
+        // annotation through absl::Status::ForEachPayload().
+        ABSL_NO_THREAD_SAFETY_ANALYSIS { status_.SetPayload(key, value); });
+  }
   if (channelz_node_ != nullptr) {
     channelz_node_->UpdateConnectivityState(state);
     channelz_node_->AddTraceEvent(
@@ -847,9 +852,9 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
             SubchannelConnectivityStateChangeString(state)));
   }
   // Notify non-health watchers.
-  watcher_list_.NotifyLocked(state, status);
+  watcher_list_.NotifyLocked(state, status_);
   // Notify health watchers.
-  health_watcher_map_.NotifyLocked(state, status);
+  health_watcher_map_.NotifyLocked(state, status_);
 }
 
 void Subchannel::OnRetryTimer() {
@@ -866,7 +871,7 @@ void Subchannel::OnRetryTimerLocked() {
 
 void Subchannel::StartConnectingLocked() {
   // Set next attempt time.
-  const Timestamp min_deadline = min_connect_timeout_ + ExecCtx::Get()->Now();
+  const Timestamp min_deadline = min_connect_timeout_ + Timestamp::Now();
   next_attempt_time_ = backoff_.NextAttemptTime();
   // Report CONNECTING.
   SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING, absl::OkStatus());
@@ -901,7 +906,7 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
   // transition back to IDLE.
   if (connecting_result_.transport == nullptr || !PublishTransportLocked()) {
     const Duration time_until_next_attempt =
-        next_attempt_time_ - ExecCtx::Get()->Now();
+        next_attempt_time_ - Timestamp::Now();
     gpr_log(GPR_INFO,
             "subchannel %p %s: connect failed (%s), backing off for %" PRId64
             " ms",

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

@@ -22,6 +22,7 @@
 #include <stddef.h>
 
 #include <deque>
+#include <functional>
 #include <map>
 #include <string>
 
@@ -278,12 +279,20 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // We do not hold refs to the data producer; the implementation is
   // expected to register itself upon construction and remove itself
   // upon destruction.
-  void AddDataProducer(DataProducerInterface* data_producer)
+  //
+  // Looks up the current data producer for type and invokes get_or_add()
+  // with a pointer to that producer in the map.  The get_or_add() function
+  // can modify the pointed-to value to update the map.  This provides a
+  // way to either re-use an existing producer or register a new one in
+  // a non-racy way.
+  void GetOrAddDataProducer(
+      UniqueTypeName type,
+      std::function<void(DataProducerInterface**)> get_or_add)
       ABSL_LOCKS_EXCLUDED(mu_);
+  // Removes the data producer from the map, if the current producer for
+  // this type is the specified producer.
   void RemoveDataProducer(DataProducerInterface* data_producer)
       ABSL_LOCKS_EXCLUDED(mu_);
-  DataProducerInterface* GetDataProducer(UniqueTypeName type)
-      ABSL_LOCKS_EXCLUDED(mu_);
 
  private:
   // A linked list of ConnectivityStateWatcherInterfaces that are monitoring