grpc 1.62.0 → 1.63.2

data/src/core/lib/surface/channel.h

@@ -1,6 +1,5 @@
 //
-//
-// Copyright 2015 gRPC authors.
+// Copyright 2024 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -14,20 +13,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-//
 
 #ifndef GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_H
 #define GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_H
 
 #include <grpc/support/port_platform.h>
 
-#include <stddef.h>
-#include <stdint.h>
-
-#include <atomic>
 #include <map>
 #include <string>
-#include <utility>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/status/statusor.h"
@@ -35,155 +28,143 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/event_engine/memory_allocator.h>
 #include <grpc/grpc.h>
 #include <grpc/impl/compression_types.h>
-#include <grpc/slice.h>
+#include <grpc/support/time.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_fwd.h"
-#include "src/core/lib/channel/channel_stack.h"  // IWYU pragma: keep
-#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gprpp/cpp_impl_of.h"
-#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/call_factory.h"
-#include "src/core/lib/transport/transport.h"
+#include "src/core/lib/transport/connectivity_state.h"
 
-/// The same as grpc_channel_destroy, but doesn't create an ExecCtx, and so
-/// is safe to use from within core.
-void grpc_channel_destroy_internal(grpc_channel* channel);
-
-/// Create a call given a grpc_channel, in order to call \a method.
-/// Progress is tied to activity on \a pollset_set. The returned call object is
-/// meant to be used with \a grpc_call_start_batch_and_execute, which relies on
-/// callbacks to signal completions. \a method and \a host need
-/// only live through the invocation of this function. If \a parent_call is
-/// non-NULL, it must be a server-side call. It will be used to propagate
-/// properties from the server call to this new client call, depending on the
-/// value of \a propagation_mask (see propagation_bits.h for possible values)
-grpc_call* grpc_channel_create_pollset_set_call(
-    grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
-    grpc_pollset_set* pollset_set, const grpc_slice& method,
-    const grpc_slice* host, grpc_core::Timestamp deadline, void* reserved);
-
-/// Get a (borrowed) pointer to this channels underlying channel stack
-grpc_channel_stack* grpc_channel_get_channel_stack(grpc_channel* channel);
-
-grpc_core::channelz::ChannelNode* grpc_channel_get_channelz_node(
-    grpc_channel* channel);
+// Forward declaration to avoid dependency loop.
+struct grpc_channel_stack;
 
 namespace grpc_core {
 
-struct RegisteredCall {
-  Slice path;
-  absl::optional<Slice> authority;
-
-  explicit RegisteredCall(const char* method_arg, const char* host_arg);
-  RegisteredCall(const RegisteredCall& other);
-  RegisteredCall& operator=(const RegisteredCall&) = delete;
-
-  ~RegisteredCall();
-};
-
-struct CallRegistrationTable {
-  Mutex mu;
-  // The map key should be owned strings rather than unowned char*'s to
-  // guarantee that it outlives calls on the core channel (which may outlast the
-  // C++ or other wrapped language Channel that registered these calls).
-  std::map<std::pair<std::string, std::string>, RegisteredCall> map
-      ABSL_GUARDED_BY(mu);
-};
+// Forward declaration to avoid dependency loop.
+class Transport;
 
 class Channel : public RefCounted<Channel>,
                 public CppImplOf<Channel, grpc_channel> {
  public:
-  static absl::StatusOr<RefCountedPtr<Channel>> Create(
-      const char* target, ChannelArgs args,
-      grpc_channel_stack_type channel_stack_type,
-      Transport* optional_transport);
+  struct RegisteredCall {
+    Slice path;
+    absl::optional<Slice> authority;
 
-  static absl::StatusOr<RefCountedPtr<Channel>> CreateWithBuilder(
-      ChannelStackBuilder* builder);
+    explicit RegisteredCall(const char* method_arg, const char* host_arg);
+    RegisteredCall(const RegisteredCall& other);
+    RegisteredCall& operator=(const RegisteredCall&) = delete;
 
-  grpc_channel_stack* channel_stack() const { return channel_stack_.get(); }
+    ~RegisteredCall();
+  };
 
-  grpc_compression_options compression_options() const {
-    return compression_options_;
-  }
+  virtual void Orphan() = 0;
 
-  channelz::ChannelNode* channelz_node() const { return channelz_node_.get(); }
+  virtual Arena* CreateArena() = 0;
+  virtual void DestroyArena(Arena* arena) = 0;
+
+  virtual bool IsLame() const = 0;
+
+  // TODO(roth): This should return a C++ type.
+  virtual grpc_call* CreateCall(grpc_call* parent_call,
+                                uint32_t propagation_mask,
+                                grpc_completion_queue* cq,
+                                grpc_pollset_set* pollset_set_alternative,
+                                Slice path, absl::optional<Slice> authority,
+                                Timestamp deadline, bool registered_method) = 0;
+
+  virtual grpc_event_engine::experimental::EventEngine* event_engine()
+      const = 0;
+
+  virtual bool SupportsConnectivityWatcher() const = 0;
 
-  Arena* CreateArena() { return call_factory_->CreateArena(); }
-  void DestroyArena(Arena* arena) { return call_factory_->DestroyArena(arena); }
+  virtual grpc_connectivity_state CheckConnectivityState(
+      bool try_to_connect) = 0;
+
+  // For external watched via the C-core API.
+  virtual void WatchConnectivityState(
+      grpc_connectivity_state last_observed_state, Timestamp deadline,
+      grpc_completion_queue* cq, void* tag) = 0;
+
+  // For internal watches.
+  virtual void AddConnectivityWatcher(
+      grpc_connectivity_state initial_state,
+      OrphanablePtr<AsyncConnectivityStateWatcherInterface> watcher) = 0;
+  virtual void RemoveConnectivityWatcher(
+      AsyncConnectivityStateWatcherInterface* watcher) = 0;
+
+  virtual void GetInfo(const grpc_channel_info* channel_info) = 0;
+
+  virtual void ResetConnectionBackoff() = 0;
 
   absl::string_view target() const { return target_; }
-  bool is_client() const { return is_client_; }
-  bool is_promising() const { return is_promising_; }
+  channelz::ChannelNode* channelz_node() const { return channelz_node_.get(); }
+  grpc_compression_options compression_options() const {
+    return compression_options_;
+  }
+
   RegisteredCall* RegisterCall(const char* method, const char* host);
 
   int TestOnlyRegisteredCalls() {
-    MutexLock lock(&registration_table_.mu);
-    return registration_table_.map.size();
+    MutexLock lock(&mu_);
+    return registration_table_.size();
   }
 
-  grpc_event_engine::experimental::EventEngine* event_engine() const {
-    return channel_stack_->EventEngine();
-  }
+  // For tests only.
+  // Pings the channel's peer.  Load-balanced channels will select one
+  // subchannel to ping.  If the channel is not connected, posts a
+  // failure to the CQ.
+  virtual void Ping(grpc_completion_queue* cq, void* tag) = 0;
 
- private:
-  Channel(bool is_client, bool is_promising, std::string target,
-          const ChannelArgs& channel_args,
-          grpc_compression_options compression_options,
-          RefCountedPtr<grpc_channel_stack> channel_stack);
+  // TODO(roth): Remove these methods when LegacyChannel goes away.
+  virtual grpc_channel_stack* channel_stack() const { return nullptr; }
+  virtual bool is_client() const { return true; }
+  virtual bool is_promising() const { return true; }
 
-  const bool is_client_;
-  const bool is_promising_;
+ protected:
+  Channel(std::string target, const ChannelArgs& channel_args);
+
+ private:
+  const std::string target_;
+  const RefCountedPtr<channelz::ChannelNode> channelz_node_;
   const grpc_compression_options compression_options_;
-  CallRegistrationTable registration_table_;
-  RefCountedPtr<channelz::ChannelNode> channelz_node_;
-  std::string target_;
-  const RefCountedPtr<grpc_channel_stack> channel_stack_;
-  const RefCountedPtr<CallFactory> call_factory_;
+
+  Mutex mu_;
+  // The map key needs to be owned strings rather than unowned char*'s to
+  // guarantee that it outlives calls on the core channel (which may outlast
+  // the C++ or other wrapped language Channel that registered these calls).
+  std::map<std::pair<std::string, std::string>, RegisteredCall>
+      registration_table_ ABSL_GUARDED_BY(mu_);
 };
 
 }  // namespace grpc_core
 
+/// The same as grpc_channel_destroy, but doesn't create an ExecCtx, and so
+/// is safe to use from within core.
+inline void grpc_channel_destroy_internal(grpc_channel* channel) {
+  grpc_core::Channel::FromC(channel)->Orphan();
+}
+
+// Return the channel's compression options.
 inline grpc_compression_options grpc_channel_compression_options(
     const grpc_channel* channel) {
   return grpc_core::Channel::FromC(channel)->compression_options();
 }
 
-inline grpc_channel_stack* grpc_channel_get_channel_stack(
-    grpc_channel* channel) {
-  return grpc_core::Channel::FromC(channel)->channel_stack();
-}
-
 inline grpc_core::channelz::ChannelNode* grpc_channel_get_channelz_node(
     grpc_channel* channel) {
   return grpc_core::Channel::FromC(channel)->channelz_node();
 }
 
-inline void grpc_channel_internal_ref(grpc_channel* channel,
-                                      const char* reason) {
-  grpc_core::Channel::FromC(channel)->Ref(DEBUG_LOCATION, reason).release();
-}
-inline void grpc_channel_internal_unref(grpc_channel* channel,
-                                        const char* reason) {
-  grpc_core::Channel::FromC(channel)->Unref(DEBUG_LOCATION, reason);
-}
-
-// Return the channel's compression options.
-grpc_compression_options grpc_channel_compression_options(
-    const grpc_channel* channel);
-
 // Ping the channels peer (load balanced channels will select one sub-channel to
 // ping); if the channel is not connected, posts a failed.
 void grpc_channel_ping(grpc_channel* channel, grpc_completion_queue* cq,

data/src/core/lib/surface/channel_create.cc

@@ -0,0 +1,109 @@
+//
+// Copyright 2015 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 <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/stats.h"
+#include "src/core/lib/debug/stats_data.h"
+#include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/lame_client.h"
+#include "src/core/lib/surface/legacy_channel.h"
+
+namespace grpc_core {
+
+absl::StatusOr<OrphanablePtr<Channel>> ChannelCreate(
+    std::string target, ChannelArgs args,
+    grpc_channel_stack_type channel_stack_type, Transport* optional_transport) {
+  global_stats().IncrementClientChannelsCreated();
+  // For client channels, canonify target string and add channel arg.
+  // Note: We don't do this for direct channels or lame channels.
+  if (channel_stack_type == GRPC_CLIENT_CHANNEL) {
+    target =
+        CoreConfiguration::Get().resolver_registry().AddDefaultPrefixIfNeeded(
+            target);
+    args = args.Set(GRPC_ARG_SERVER_URI, target);
+  }
+  // Set default authority if needed.
+  if (!args.GetString(GRPC_ARG_DEFAULT_AUTHORITY).has_value()) {
+    auto ssl_override = args.GetString(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG);
+    if (ssl_override.has_value()) {
+      args = args.Set(GRPC_ARG_DEFAULT_AUTHORITY,
+                      std::string(ssl_override.value()));
+    }
+  }
+  // Check whether channelz is enabled.
+  if (args.GetBool(GRPC_ARG_ENABLE_CHANNELZ)
+          .value_or(GRPC_ENABLE_CHANNELZ_DEFAULT)) {
+    // Get parameters needed to create the channelz node.
+    const size_t channel_tracer_max_memory = std::max(
+        0, args.GetInt(GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE)
+               .value_or(GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT));
+    const bool is_internal_channel =
+        args.GetBool(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL).value_or(false);
+    // Create the channelz node.
+    std::string channelz_node_target{target.empty() ? "unknown" : target};
+    auto channelz_node = MakeRefCounted<channelz::ChannelNode>(
+        channelz_node_target, channel_tracer_max_memory, is_internal_channel);
+    channelz_node->AddTraceEvent(
+        channelz::ChannelTrace::Severity::Info,
+        grpc_slice_from_static_string("Channel created"));
+    // Add channelz node to channel args.
+    // We remove the is_internal_channel arg, since we no longer need it.
+    args = args.Remove(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL)
+               .SetObject(std::move(channelz_node));
+  }
+  // Add transport to args.
+  if (optional_transport != nullptr) {
+    args = args.SetObject(optional_transport);
+  }
+  // Delegate to legacy channel impl.
+  return LegacyChannel::Create(std::move(target), std::move(args),
+                               channel_stack_type);
+}
+
+}  // namespace grpc_core
+
+grpc_channel* grpc_lame_client_channel_create(const char* target,
+                                              grpc_status_code error_code,
+                                              const char* error_message) {
+  grpc_core::ExecCtx exec_ctx;
+  GRPC_API_TRACE(
+      "grpc_lame_client_channel_create(target=%s, error_code=%d, "
+      "error_message=%s)",
+      3, (target, (int)error_code, error_message));
+  if (error_code == GRPC_STATUS_OK) error_code = GRPC_STATUS_UNKNOWN;
+  grpc_core::ChannelArgs args =
+      grpc_core::CoreConfiguration::Get()
+          .channel_args_preconditioning()
+          .PreconditionChannelArgs(nullptr)
+          .Set(GRPC_ARG_LAME_FILTER_ERROR,
+               grpc_core::ChannelArgs::Pointer(
+                   new absl::Status(static_cast<absl::StatusCode>(error_code),
+                                    error_message),
+                   &grpc_core::kLameFilterErrorArgVtable));
+  auto channel =
+      grpc_core::ChannelCreate(target == nullptr ? "" : target, std::move(args),
+                               GRPC_CLIENT_LAME_CHANNEL, nullptr);
+  GPR_ASSERT(channel.ok());
+  return channel->release()->c_ptr();
+}

data/src/core/lib/surface/{builtins.cc → channel_create.h}

@@ -1,4 +1,5 @@
-// Copyright 2021 gRPC authors.
+//
+// Copyright 2024 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,27 +12,31 @@
 // 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_SURFACE_CHANNEL_CREATE_H
+#define GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_CREATE_H
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/surface/builtins.h"
+#include <string>
 
-#include "src/core/lib/channel/call_tracer.h"
-#include "src/core/lib/config/core_configuration.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/surface/lame_client.h"
-#include "src/core/lib/surface/server.h"
 
 namespace grpc_core {
 
-void RegisterBuiltins(CoreConfiguration::Builder* builder) {
-  RegisterServerCallTracerFilter(builder);
-  builder->channel_init()
-      ->RegisterFilter<LameClientFilter>(GRPC_CLIENT_LAME_CHANNEL)
-      .Terminal();
-  builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_CHANNEL, &Server::kServerTopFilter)
-      .BeforeAll();
-}
+class Transport;
+
+// Creates a client channel.
+absl::StatusOr<OrphanablePtr<Channel>> ChannelCreate(
+    std::string target, ChannelArgs args,
+    grpc_channel_stack_type channel_stack_type, Transport* optional_transport);
 
 }  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_SURFACE_CHANNEL_CREATE_H

data/src/core/lib/surface/channel_init.cc

@@ -141,9 +141,9 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
       GPR_ASSERT(registration->after_.empty());
       GPR_ASSERT(registration->before_.empty());
       GPR_ASSERT(!registration->before_all_);
-      terminal_filters.emplace_back(registration->filter_, nullptr,
-                                    std::move(registration->predicates_),
-                                    registration->registration_source_);
+      terminal_filters.emplace_back(
+          registration->filter_, nullptr, std::move(registration->predicates_),
+          registration->skip_v3_, registration->registration_source_);
     } else {
       dependencies[registration->filter_];  // Ensure it's in the map.
     }
@@ -223,9 +223,9 @@ ChannelInit::StackConfig ChannelInit::BuildStackConfig(
   while (!dependencies.empty()) {
     auto filter = take_ready_dependency();
     auto* registration = filter_to_registration[filter];
-    filters.emplace_back(filter, registration->vtable_,
-                         std::move(registration->predicates_),
-                         registration->registration_source_);
+    filters.emplace_back(
+        filter, registration->vtable_, std::move(registration->predicates_),
+        registration->skip_v3_, registration->registration_source_);
     for (auto& p : dependencies) {
       p.second.erase(filter);
     }
@@ -414,6 +414,7 @@ absl::StatusOr<ChannelInit::StackSegment> ChannelInit::CreateStackSegment(
   size_t channel_data_alignment = 0;
   // Based on predicates build a list of filters to include in this segment.
   for (const auto& filter : stack_config.filters) {
+    if (filter.skip_v3) continue;
     if (!filter.CheckPredicates(args)) continue;
     if (filter.vtable == nullptr) {
       return absl::InvalidArgumentError(

data/src/core/lib/surface/channel_init.h

@@ -162,6 +162,10 @@ class ChannelInit {
     // Add a predicate that ensures this filter does not appear in the minimal
     // stack.
     FilterRegistration& ExcludeFromMinimalStack();
+    FilterRegistration& SkipV3() {
+      skip_v3_ = true;
+      return *this;
+    }
 
    private:
     friend class ChannelInit;
@@ -172,6 +176,7 @@ class ChannelInit {
     std::vector<InclusionPredicate> predicates_;
     bool terminal_ = false;
     bool before_all_ = false;
+    bool skip_v3_ = false;
     SourceLocation registration_source_;
   };
 
@@ -195,6 +200,15 @@ class ChannelInit {
                             registration_source);
     }
 
+    // Filter does not participate in v3
+    template <typename Filter>
+    FilterRegistration& RegisterV2Filter(
+        grpc_channel_stack_type type, SourceLocation registration_source = {}) {
+      return RegisterFilter(type, &Filter::kFilter, nullptr,
+                            registration_source)
+          .SkipV3();
+    }
+
     // Register a post processor for the builder.
     // These run after the main graph has been placed into the builder.
     // At most one filter per slot per channel stack type can be added.
@@ -274,16 +288,18 @@ class ChannelInit {
  private:
   struct Filter {
     Filter(const grpc_channel_filter* filter, const ChannelFilterVtable* vtable,
-           std::vector<InclusionPredicate> predicates,
+           std::vector<InclusionPredicate> predicates, bool skip_v3,
            SourceLocation registration_source)
         : filter(filter),
           vtable(vtable),
           predicates(std::move(predicates)),
-          registration_source(registration_source) {}
+          registration_source(registration_source),
+          skip_v3(skip_v3) {}
     const grpc_channel_filter* filter;
     const ChannelFilterVtable* vtable;
     std::vector<InclusionPredicate> predicates;
     SourceLocation registration_source;
+    bool skip_v3 = false;
     bool CheckPredicates(const ChannelArgs& args) const;
   };
   struct StackConfig {

data/src/core/lib/surface/init.cc

@@ -72,20 +72,13 @@ void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
   builder->channel_init()
       ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
       .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
-  if (IsV3ServerAuthFilterEnabled()) {
-    builder->channel_init()
-        ->RegisterFilter<ServerAuthFilter>(GRPC_SERVER_CHANNEL)
-        .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
-  } else {
-    builder->channel_init()
-        ->RegisterFilter<LegacyServerAuthFilter>(GRPC_SERVER_CHANNEL)
-        .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
-  }
+  builder->channel_init()
+      ->RegisterFilter<ServerAuthFilter>(GRPC_SERVER_CHANNEL)
+      .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
   builder->channel_init()
       ->RegisterFilter<GrpcServerAuthzFilter>(GRPC_SERVER_CHANNEL)
       .IfHasChannelArg(GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER)
-      .After<ServerAuthFilter>()
-      .After<LegacyServerAuthFilter>();
+      .After<ServerAuthFilter>();
 }
 }  // namespace grpc_core
 
@@ -136,8 +129,8 @@ void grpc_shutdown_internal_locked(void)
   g_shutting_down_cv->SignalAll();
 }
 
-void grpc_shutdown_internal(void* /*ignored*/) {
-  GRPC_API_TRACE("grpc_shutdown_internal", 0, ());
+void grpc_shutdown_from_cleanup_thread(void* /*ignored*/) {
+  GRPC_API_TRACE("grpc_shutdown_from_cleanup_thread", 0, ());
   grpc_core::MutexLock lock(g_init_mu);
   // We have released lock from the shutdown thread and it is possible that
   // another grpc_init has been called, and do nothing if that is the case.
@@ -145,6 +138,7 @@ void grpc_shutdown_internal(void* /*ignored*/) {
     return;
   }
   grpc_shutdown_internal_locked();
+  gpr_log(GPR_DEBUG, "grpc_shutdown from cleanup thread done");
 }
 
 void grpc_shutdown(void) {
@@ -165,6 +159,7 @@ void grpc_shutdown(void) {
       gpr_log(GPR_DEBUG, "grpc_shutdown starts clean-up now");
       g_shutting_down = true;
       grpc_shutdown_internal_locked();
+      gpr_log(GPR_DEBUG, "grpc_shutdown done");
     } else {
       // spawn a detached thread to do the actual clean up in case we are
       // currently in an executor thread.
@@ -172,7 +167,7 @@ void grpc_shutdown(void) {
       g_initializations++;
       g_shutting_down = true;
       grpc_core::Thread cleanup_thread(
-          "grpc_shutdown", grpc_shutdown_internal, nullptr, nullptr,
+          "grpc_shutdown", grpc_shutdown_from_cleanup_thread, nullptr, nullptr,
           grpc_core::Thread::Options().set_joinable(false).set_tracked(false));
       cleanup_thread.Start();
     }

data/src/core/lib/surface/lame_client.cc

@@ -23,6 +23,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 
 #include <grpc/grpc.h>
@@ -53,8 +54,6 @@
 // Avoid some IWYU confusion:
 // IWYU pragma: no_include "src/core/lib/gprpp/orphanable.h"
 
-#define GRPC_ARG_LAME_FILTER_ERROR "grpc.lame_filter_error"
-
 namespace grpc_core {
 
 const grpc_channel_filter LameClientFilter::kFilter =
@@ -126,11 +125,11 @@ void* ErrorCopy(void* p) {
 void ErrorDestroy(void* p) { delete static_cast<absl::Status*>(p); }
 int ErrorCompare(void* p, void* q) { return QsortCompare(p, q); }
 
+}  // namespace
+
 const grpc_arg_pointer_vtable kLameFilterErrorArgVtable = {
     ErrorCopy, ErrorDestroy, ErrorCompare};
 
-}  // namespace
-
 grpc_arg MakeLameClientErrorArg(grpc_error_handle* error) {
   return grpc_channel_arg_pointer_create(
       const_cast<char*>(GRPC_ARG_LAME_FILTER_ERROR), error,
@@ -138,27 +137,3 @@ grpc_arg MakeLameClientErrorArg(grpc_error_handle* error) {
 }
 
 }  // namespace grpc_core
-
-grpc_channel* grpc_lame_client_channel_create(const char* target,
-                                              grpc_status_code error_code,
-                                              const char* error_message) {
-  grpc_core::ExecCtx exec_ctx;
-  GRPC_API_TRACE(
-      "grpc_lame_client_channel_create(target=%s, error_code=%d, "
-      "error_message=%s)",
-      3, (target, (int)error_code, error_message));
-  if (error_code == GRPC_STATUS_OK) error_code = GRPC_STATUS_UNKNOWN;
-  grpc_core::ChannelArgs args =
-      grpc_core::CoreConfiguration::Get()
-          .channel_args_preconditioning()
-          .PreconditionChannelArgs(nullptr)
-          .Set(GRPC_ARG_LAME_FILTER_ERROR,
-               grpc_core::ChannelArgs::Pointer(
-                   new absl::Status(static_cast<absl::StatusCode>(error_code),
-                                    error_message),
-                   &grpc_core::kLameFilterErrorArgVtable));
-  auto channel = grpc_core::Channel::Create(target, std::move(args),
-                                            GRPC_CLIENT_LAME_CHANNEL, nullptr);
-  GPR_ASSERT(channel.ok());
-  return channel->release()->c_ptr();
-}

data/src/core/lib/surface/lame_client.h

@@ -38,9 +38,9 @@
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/transport.h"
 
+#define GRPC_ARG_LAME_FILTER_ERROR "grpc.lame_filter_error"
+
 namespace grpc_core {
-// Does NOT take ownership of error.
-grpc_arg MakeLameClientErrorArg(grpc_error_handle* error);
 
 // This filter becomes the entire channel stack for a channel that fails to be
 // created. Every call returns failure.
@@ -66,6 +66,11 @@ class LameClientFilter : public ChannelFilter {
   };
   std::unique_ptr<State> state_;
 };
+
+extern const grpc_arg_pointer_vtable kLameFilterErrorArgVtable;
+
+grpc_arg MakeLameClientErrorArg(grpc_error_handle* error);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_SURFACE_LAME_CLIENT_H