grpc 1.46.3-x86_64-linux → 1.47.0-x86_64-linux

data/src/core/lib/channel/channel_stack_builder.cc

@@ -20,20 +20,14 @@
 
 #include "src/core/lib/channel/channel_stack_builder.h"
 
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
+#include <algorithm>
+#include <utility>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
-#include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {
 
-ChannelStackBuilder::~ChannelStackBuilder() {
-  grpc_channel_args_destroy(args_);
-}
+ChannelStackBuilder::~ChannelStackBuilder() = default;
 
 ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   if (target == nullptr) {
@@ -44,21 +38,17 @@ ChannelStackBuilder& ChannelStackBuilder::SetTarget(const char* target) {
   return *this;
 }
 
-ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(
-    const grpc_channel_args* args) {
-  grpc_channel_args_destroy(args_);
-  args_ = grpc_channel_args_copy(args);
+ChannelStackBuilder& ChannelStackBuilder::SetChannelArgs(ChannelArgs args) {
+  args_ = std::move(args);
   return *this;
 }
 
-void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter,
-                                        PostInitFunc post_init) {
-  stack_.insert(stack_.begin(), {filter, std::move(post_init)});
+void ChannelStackBuilder::PrependFilter(const grpc_channel_filter* filter) {
+  stack_.insert(stack_.begin(), filter);
 }
 
-void ChannelStackBuilder::AppendFilter(const grpc_channel_filter* filter,
-                                       PostInitFunc post_init) {
-  stack_.push_back({filter, std::move(post_init)});
+void ChannelStackBuilder::AppendFilter(const grpc_channel_filter* filter) {
+  stack_.push_back(filter);
 }
 
 }  // namespace grpc_core

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

@@ -17,16 +17,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
-
-#include <functional>
+#include <string>
 #include <vector>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
 typedef struct grpc_channel_stack grpc_channel_stack;
@@ -43,17 +43,6 @@ namespace grpc_core {
 // and a transport.
 class ChannelStackBuilder {
  public:
-  // A function that will be called after the channel stack is successfully
-  // built.
-  using PostInitFunc = std::function<void(grpc_channel_stack* channel_stack,
-                                          grpc_channel_element* elem)>;
-
-  // One filter in the currently building stack.
-  struct StackEntry {
-    const grpc_channel_filter* filter;
-    PostInitFunc post_init;
-  };
-
   // Initialize with a name.
   ChannelStackBuilder(const char* name, grpc_channel_stack_type type)
       : name_(name), type_(type) {}
@@ -77,31 +66,29 @@ class ChannelStackBuilder {
   grpc_transport* transport() const { return transport_; }
 
   // Set channel args (takes a copy of them).
-  ChannelStackBuilder& SetChannelArgs(const grpc_channel_args* args);
+  ChannelStackBuilder& SetChannelArgs(ChannelArgs args);
 
   // Query the channel args.
-  const grpc_channel_args* channel_args() const { return args_; }
+  const ChannelArgs& channel_args() const { return args_; }
 
   // Mutable vector of proposed stack entries.
-  std::vector<StackEntry>* mutable_stack() { return &stack_; }
+  std::vector<const grpc_channel_filter*>* mutable_stack() { return &stack_; }
 
   // The type of channel stack being built.
   grpc_channel_stack_type channel_stack_type() const { return type_; }
 
   // Helper to add a filter to the front of the stack.
-  void PrependFilter(const grpc_channel_filter* filter, PostInitFunc post_init);
+  void PrependFilter(const grpc_channel_filter* filter);
 
   // Helper to add a filter to the end of the stack.
-  void AppendFilter(const grpc_channel_filter* filter, PostInitFunc post_init);
+  void AppendFilter(const grpc_channel_filter* filter);
 
   // Build the channel stack.
   // After success, *result holds the new channel stack,
   // prefix_bytes are allocated before the channel stack,
-  // initial_refs, destroy, destroy_arg are as per grpc_channel_stack_init
+  // destroy is as per grpc_channel_stack_init
   // On failure, *result is nullptr.
-  virtual grpc_error_handle Build(size_t prefix_bytes, int initial_refs,
-                                  grpc_iomgr_cb_func destroy, void* destroy_arg,
-                                  void** result) = 0;
+  virtual absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() = 0;
 
  protected:
   ~ChannelStackBuilder();
@@ -118,10 +105,11 @@ class ChannelStackBuilder {
   // The transport
   grpc_transport* transport_ = nullptr;
   // Channel args
-  const grpc_channel_args* args_ = nullptr;
+  ChannelArgs args_;
   // The in-progress stack
-  std::vector<StackEntry> stack_;
+  std::vector<const grpc_channel_filter*> stack_;
 };
+
 }  // namespace grpc_core
 
 #endif  // GRPC_CORE_LIB_CHANNEL_CHANNEL_STACK_BUILDER_H

data/src/core/lib/channel/channel_stack_builder_impl.cc

@@ -22,40 +22,35 @@
 
 #include <string.h>
 
+#include <vector>
+
+#include "absl/status/status.h"
+
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
-grpc_error_handle ChannelStackBuilderImpl::Build(size_t prefix_bytes,
-                                                 int initial_refs,
-                                                 grpc_iomgr_cb_func destroy,
-                                                 void* destroy_arg,
-                                                 void** result) {
+absl::StatusOr<RefCountedPtr<grpc_channel_stack>>
+ChannelStackBuilderImpl::Build() {
   auto* stack = mutable_stack();
 
-  // create an array of filters
-  std::vector<const grpc_channel_filter*> filters;
-  filters.reserve(stack->size());
-  for (const auto& elem : *stack) {
-    filters.push_back(elem.filter);
-  }
-
   // calculate the size of the channel stack
   size_t channel_stack_size =
-      grpc_channel_stack_size(filters.data(), filters.size());
+      grpc_channel_stack_size(stack->data(), stack->size());
 
-  // allocate memory, with prefix_bytes followed by channel_stack_size
-  *result = gpr_zalloc(prefix_bytes + channel_stack_size);
-  // fetch a pointer to the channel stack
-  grpc_channel_stack* channel_stack = reinterpret_cast<grpc_channel_stack*>(
-      static_cast<char*>(*result) + prefix_bytes);
+  // allocate memory
+  auto* channel_stack =
+      static_cast<grpc_channel_stack*>(gpr_zalloc(channel_stack_size));
 
-  const grpc_channel_args* final_args;
+  ChannelArgs final_args = channel_args();
   if (transport() != nullptr) {
     static const grpc_arg_pointer_vtable vtable = {
         // copy
@@ -65,38 +60,38 @@ grpc_error_handle ChannelStackBuilderImpl::Build(size_t prefix_bytes,
         // cmp
         [](void* a, void* b) { return QsortCompare(a, b); },
     };
-    grpc_arg arg = grpc_channel_arg_pointer_create(
-        const_cast<char*>(GRPC_ARG_TRANSPORT), transport(), &vtable);
-    final_args = grpc_channel_args_copy_and_add(channel_args(), &arg, 1);
-  } else {
-    final_args = channel_args();
+    final_args = final_args.Set(GRPC_ARG_TRANSPORT,
+                                ChannelArgs::Pointer(transport(), &vtable));
   }
 
   // and initialize it
+  const grpc_channel_args* c_args = final_args.ToC();
   grpc_error_handle error = grpc_channel_stack_init(
-      initial_refs, destroy, destroy_arg == nullptr ? *result : destroy_arg,
-      filters.data(), filters.size(), final_args, name(), channel_stack);
-
-  if (final_args != channel_args()) {
-    grpc_channel_args_destroy(final_args);
-  }
+      1,
+      [](void* p, grpc_error_handle) {
+        auto* stk = static_cast<grpc_channel_stack*>(p);
+        grpc_channel_stack_destroy(stk);
+        gpr_free(stk);
+      },
+      channel_stack, stack->data(), stack->size(), c_args, name(),
+      channel_stack);
+  grpc_channel_args_destroy(c_args);
 
   if (error != GRPC_ERROR_NONE) {
     grpc_channel_stack_destroy(channel_stack);
-    gpr_free(*result);
-    *result = nullptr;
-    return error;
+    gpr_free(channel_stack);
+    auto status = grpc_error_to_absl_status(error);
+    GRPC_ERROR_UNREF(error);
+    return status;
   }
 
   // run post-initialization functions
-  for (size_t i = 0; i < filters.size(); i++) {
-    if ((*stack)[i].post_init != nullptr) {
-      (*stack)[i].post_init(channel_stack,
-                            grpc_channel_stack_element(channel_stack, i));
-    }
+  for (size_t i = 0; i < stack->size(); i++) {
+    auto* elem = grpc_channel_stack_element(channel_stack, i);
+    elem->filter->post_init_channel_elem(channel_stack, elem);
   }
 
-  return GRPC_ERROR_NONE;
+  return RefCountedPtr<grpc_channel_stack>(channel_stack);
 }
 
 }  // namespace grpc_core

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

@@ -17,11 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdbool.h>
+#include "absl/status/statusor.h"
 
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
 
@@ -39,9 +38,7 @@ class ChannelStackBuilderImpl final : public ChannelStackBuilder {
   // prefix_bytes are allocated before the channel stack,
   // initial_refs, destroy, destroy_arg are as per grpc_channel_stack_init
   // On failure, *result is nullptr.
-  grpc_error_handle Build(size_t prefix_bytes, int initial_refs,
-                          grpc_iomgr_cb_func destroy, void* destroy_arg,
-                          void** result) override;
+  absl::StatusOr<RefCountedPtr<grpc_channel_stack>> Build() override;
 };
 }  // namespace grpc_core
 

data/src/core/lib/channel/channel_trace.cc

@@ -20,24 +20,19 @@
 
 #include "src/core/lib/channel/channel_trace.h"
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <algorithm>
+#include <map>
+#include <string>
+#include <utility>
 
-#include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
-#include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/channel.h"
-#include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/error_utils.h"
+#include "src/core/lib/slice/slice_refcount.h"
 
 namespace grpc_core {
 namespace channelz {

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

@@ -21,11 +21,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/grpc.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/slice.h>
+#include <grpc/support/sync.h>
 
-#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {

data/src/core/lib/channel/channelz.cc

@@ -20,37 +20,32 @@
 
 #include "src/core/lib/channel/channelz.h"
 
-#include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 
+#include <algorithm>
 #include <atomic>
+#include <type_traits>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/strip.h"
 
-#include <grpc/grpc.h>
-#include <grpc/support/alloc.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/time.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/channel/channelz_registry.h"
-#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/slice/b64.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/surface/channel.h"
-#include "src/core/lib/surface/server.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {

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

@@ -21,23 +21,28 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
 #include <atomic>
+#include <cstdint>
+#include <map>
 #include <set>
 #include <string>
+#include <utility>
 
 #include "absl/container/inlined_vector.h"
+#include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include <grpc/grpc.h>
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/slice.h>
 
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/gpr/time_precise.h"
-#include "src/core/lib/gprpp/manual_constructor.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/iomgr/error.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/json/json.h"
 
 // Channel arg key for channelz node.
@@ -176,6 +181,10 @@ class ChannelNode : public BaseNode {
   ChannelNode(std::string target, size_t channel_tracer_max_nodes,
               bool is_internal_channel);
 
+  static absl::string_view ChannelArgName() {
+    return GRPC_ARG_CHANNELZ_CHANNEL_NODE;
+  }
+
   // Returns the string description of the given connectivity state.
   static const char* GetChannelConnectivityStateChangeString(
       grpc_connectivity_state state);

data/src/core/lib/channel/channelz_registry.cc

@@ -21,39 +21,32 @@
 #include "src/core/lib/channel/channelz_registry.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <cstring>
+#include <utility>
 
 #include "absl/container/inlined_vector.h"
 
-#include <grpc/support/alloc.h>
+#include <grpc/grpc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <grpc/support/sync.h>
 
-#include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/json/json.h"
 
 namespace grpc_core {
 namespace channelz {
 namespace {
 
-// singleton instance of the registry.
-ChannelzRegistry* g_channelz_registry = nullptr;
-
 const int kPaginationLimit = 100;
 
 }  // anonymous namespace
 
-void ChannelzRegistry::Init() { g_channelz_registry = new ChannelzRegistry(); }
-
-void ChannelzRegistry::Shutdown() { delete g_channelz_registry; }
-
 ChannelzRegistry* ChannelzRegistry::Default() {
-  GPR_DEBUG_ASSERT(g_channelz_registry != nullptr);
-  return g_channelz_registry;
+  static ChannelzRegistry* singleton = new ChannelzRegistry();
+  return singleton;
 }
 
 void ChannelzRegistry::InternalRegister(BaseNode* node) {

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

@@ -21,13 +21,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
-
+#include <cstdint>
 #include <map>
 #include <string>
 
-#include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_core {
@@ -37,12 +36,6 @@ namespace channelz {
 // channelz bookkeeping. All objects share globally distributed uuids.
 class ChannelzRegistry {
  public:
-  // To be called in grpc_init()
-  static void Init();
-
-  // To be called in grpc_shutdown();
-  static void Shutdown();
-
   static void Register(BaseNode* node) {
     return Default()->InternalRegister(node);
   }
@@ -67,6 +60,14 @@ class ChannelzRegistry {
   // This can aid in debugging channelz code.
   static void LogAllEntities() { Default()->InternalLogAllEntities(); }
 
+  // Test only helper function to reset to initial state.
+  static void TestOnlyReset() {
+    auto* p = Default();
+    MutexLock lock(&p->mu_);
+    p->node_map_.clear();
+    p->uuid_generator_ = 0;
+  }
+
  private:
   // Returned the singleton instance of ChannelzRegistry;
   static ChannelzRegistry* Default();

data/src/core/lib/channel/connected_channel.cc

@@ -20,17 +20,17 @@
 
 #include "src/core/lib/channel/connected_channel.h"
 
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <grpc/byte_buffer.h>
-#include <grpc/slice_buffer.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/gpr/alloc.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/transport/transport.h"
 
 #define MAX_BUFFER_LENGTH 8192
@@ -184,7 +184,8 @@ static grpc_error_handle connected_channel_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(args->is_last);
-  cd->transport = nullptr;
+  cd->transport = grpc_channel_args_find_pointer<grpc_transport>(
+      args->channel_args, GRPC_ARG_TRANSPORT);
   return GRPC_ERROR_NONE;
 }
 
@@ -211,36 +212,25 @@ const grpc_channel_filter grpc_connected_filter = {
     connected_channel_destroy_call_elem,
     sizeof(channel_data),
     connected_channel_init_channel_elem,
+    [](grpc_channel_stack* channel_stack, grpc_channel_element* elem) {
+      /* HACK(ctiller): increase call stack size for the channel to make space
+         for channel data. We need a cleaner (but performant) way to do this,
+         and I'm not sure what that is yet.
+         This is only "safe" because call stacks place no additional data after
+         the last call element, and the last call element MUST be the connected
+         channel. */
+      channel_stack->call_stack_size += grpc_transport_stream_size(
+          static_cast<channel_data*>(elem->channel_data)->transport);
+    },
     connected_channel_destroy_channel_elem,
     connected_channel_get_channel_info,
     "connected",
 };
 
-static void bind_transport(grpc_channel_stack* channel_stack,
-                           grpc_channel_element* elem, void* t) {
-  channel_data* cd = static_cast<channel_data*>(elem->channel_data);
-  GPR_ASSERT(elem->filter == &grpc_connected_filter);
-  GPR_ASSERT(cd->transport == nullptr);
-  cd->transport = static_cast<grpc_transport*>(t);
-
-  /* HACK(ctiller): increase call stack size for the channel to make space
-     for channel data. We need a cleaner (but performant) way to do this,
-     and I'm not sure what that is yet.
-     This is only "safe" because call stacks place no additional data after
-     the last call element, and the last call element MUST be the connected
-     channel. */
-  channel_stack->call_stack_size +=
-      grpc_transport_stream_size(static_cast<grpc_transport*>(t));
-}
-
 bool grpc_add_connected_filter(grpc_core::ChannelStackBuilder* builder) {
   grpc_transport* t = builder->transport();
   GPR_ASSERT(t != nullptr);
-  builder->AppendFilter(
-      &grpc_connected_filter,
-      [t](grpc_channel_stack* stk, grpc_channel_element* elem) {
-        bind_transport(stk, elem, t);
-      });
+  builder->AppendFilter(&grpc_connected_filter);
   return true;
 }
 

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

@@ -23,6 +23,7 @@
 
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/transport/transport.h"
 
 extern const grpc_channel_filter grpc_connected_filter;