grpc 1.28.0 → 1.37.0

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

@@ -23,14 +23,16 @@
 
 #include <grpc/grpc.h>
 
+#include <set>
 #include <string>
 
+#include "absl/container/inlined_vector.h"
+#include "absl/types/optional.h"
+
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/atomic.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
-#include "src/core/lib/gprpp/map.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"
@@ -41,8 +43,9 @@
 // Channel arg key for channelz node.
 #define GRPC_ARG_CHANNELZ_CHANNEL_NODE "grpc.channelz_channel_node"
 
-// Channel arg key to encode the channelz uuid of the channel's parent.
-#define GRPC_ARG_CHANNELZ_PARENT_UUID "grpc.channelz_parent_uuid"
+// Channel arg key for indicating an internal channel.
+#define GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL \
+  "grpc.channelz_is_internal_channel"
 
 /** This is the default value for whether or not to enable channelz. If
  * GRPC_ARG_ENABLE_CHANNELZ is set, it will override this default value. */
@@ -52,16 +55,12 @@
  * events per channel trace node. If
  * GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE is set, it will override
  * this default value. */
-#define GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT 1024 * 4
+#define GRPC_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE_DEFAULT (1024 * 4)
 
 namespace grpc_core {
 
 namespace channelz {
 
-// Helpers for getting and setting GRPC_ARG_CHANNELZ_PARENT_UUID.
-grpc_arg MakeParentUuidArg(intptr_t parent_uuid);
-intptr_t GetParentUuidFromArgs(const grpc_channel_args& args);
-
 class SocketNode;
 class ListenSocketNode;
 
@@ -88,7 +87,7 @@ class BaseNode : public RefCounted<BaseNode> {
   BaseNode(EntityType type, std::string name);
 
  public:
-  virtual ~BaseNode();
+  ~BaseNode() override;
 
   // All children must implement this function.
   virtual Json RenderJson() = 0;
@@ -167,7 +166,7 @@ class CallCountingHelper {
   void CollectData(CounterData* out);
 
   // Really zero-sized, but 0-sized arrays are illegal on MSVC.
-  InlinedVector<AtomicCounterData, 1> per_cpu_counter_data_storage_;
+  absl::InlinedVector<AtomicCounterData, 1> per_cpu_counter_data_storage_;
   size_t num_cores_ = 0;
 };
 
@@ -175,14 +174,12 @@ class CallCountingHelper {
 class ChannelNode : public BaseNode {
  public:
   ChannelNode(std::string target, size_t channel_tracer_max_nodes,
-              intptr_t parent_uuid);
+              bool is_internal_channel);
 
   // Returns the string description of the given connectivity state.
   static const char* GetChannelConnectivityStateChangeString(
       grpc_connectivity_state state);
 
-  intptr_t parent_uuid() const { return parent_uuid_; }
-
   Json RenderJson() override;
 
   // proxy methods to composed classes.
@@ -212,32 +209,28 @@ class ChannelNode : public BaseNode {
   void RemoveChildSubchannel(intptr_t child_uuid);
 
  private:
-  void PopulateChildRefs(Json::Object* json);
-
-  // to allow the channel trace test to access trace_.
+  // Allows the channel trace test to access trace_.
   friend class testing::ChannelNodePeer;
 
+  void PopulateChildRefs(Json::Object* json);
+
   std::string target_;
   CallCountingHelper call_counter_;
   ChannelTrace trace_;
-  const intptr_t parent_uuid_;
 
   // Least significant bit indicates whether the value is set.  Remaining
   // bits are a grpc_connectivity_state value.
   Atomic<int> connectivity_state_{0};
 
-  Mutex child_mu_;  // Guards child maps below.
-  // TODO(roth): We don't actually use the values here, only the keys, so
-  // these should be sets instead of maps, but we don't currently have a set
-  // implementation.  Change this if/when we have one.
-  std::map<intptr_t, bool> child_channels_;
-  std::map<intptr_t, bool> child_subchannels_;
+  Mutex child_mu_;  // Guards sets below.
+  std::set<intptr_t> child_channels_;
+  std::set<intptr_t> child_subchannels_;
 };
 
 // Handles channelz bookkeeping for servers
 class ServerNode : public BaseNode {
  public:
-  ServerNode(grpc_server* server, size_t channel_tracer_max_nodes);
+  explicit ServerNode(size_t channel_tracer_max_nodes);
 
   ~ServerNode() override;
 
@@ -276,10 +269,37 @@ class ServerNode : public BaseNode {
   std::map<intptr_t, RefCountedPtr<ListenSocketNode>> child_listen_sockets_;
 };
 
+#define GRPC_ARG_CHANNELZ_SECURITY "grpc.internal.channelz_security"
+
 // Handles channelz bookkeeping for sockets
 class SocketNode : public BaseNode {
  public:
-  SocketNode(std::string local, std::string remote, std::string name);
+  struct Security : public RefCounted<Security> {
+    struct Tls {
+      enum class NameType { kUnset = 0, kStandardName = 1, kOtherName = 2 };
+      NameType type = NameType::kUnset;
+      // Holds the value of standard_name or other_names if type is not kUnset.
+      std::string name;
+      std::string local_certificate;
+      std::string remote_certificate;
+
+      Json RenderJson();
+    };
+    enum class ModelType { kUnset = 0, kTls = 1, kOther = 2 };
+    ModelType type = ModelType::kUnset;
+    absl::optional<Tls> tls;
+    absl::optional<Json> other;
+
+    Json RenderJson();
+
+    grpc_arg MakeChannelArg() const;
+
+    static RefCountedPtr<Security> GetFromChannelArgs(
+        const grpc_channel_args* args);
+  };
+
+  SocketNode(std::string local, std::string remote, std::string name,
+             RefCountedPtr<Security> security);
   ~SocketNode() override {}
 
   Json RenderJson() override;
@@ -313,6 +333,7 @@ class SocketNode : public BaseNode {
   Atomic<gpr_cycle_counter> last_message_received_cycle_{0};
   std::string local_;
   std::string remote_;
+  RefCountedPtr<Security> const security_;
 };
 
 // Handles channelz bookkeeping for listen sockets

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

@@ -21,6 +21,8 @@
 #include <algorithm>
 #include <cstring>
 
+#include "absl/container/inlined_vector.h"
+
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/channelz_registry.h"
@@ -76,21 +78,21 @@ RefCountedPtr<BaseNode> ChannelzRegistry::InternalGet(intptr_t uuid) {
   // Found node.  Return only if its refcount is not zero (i.e., when we
   // know that there is no other thread about to destroy it).
   BaseNode* node = it->second;
-  if (!node->RefIfNonZero()) return nullptr;
-  return RefCountedPtr<BaseNode>(node);
+  return node->RefIfNonZero();
 }
 
 std::string ChannelzRegistry::InternalGetTopChannels(
     intptr_t start_channel_id) {
-  InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
+  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
     for (auto it = node_map_.lower_bound(start_channel_id);
          it != node_map_.end(); ++it) {
       BaseNode* node = it->second;
+      RefCountedPtr<BaseNode> node_ref;
       if (node->type() == BaseNode::EntityType::kTopLevelChannel &&
-          node->RefIfNonZero()) {
+          (node_ref = node->RefIfNonZero()) != nullptr) {
         // Check if we are over pagination limit to determine if we need to set
         // the "end" element. If we don't go through this block, we know that
         // when the loop terminates, we have <= to kPaginationLimit.
@@ -98,10 +100,10 @@ std::string ChannelzRegistry::InternalGetTopChannels(
         // refcount, we need to decrease it, but we can't unref while
         // holding the lock, because this may lead to a deadlock.
         if (top_level_channels.size() == kPaginationLimit) {
-          node_after_pagination_limit.reset(node);
+          node_after_pagination_limit = std::move(node_ref);
           break;
         }
-        top_level_channels.emplace_back(node);
+        top_level_channels.emplace_back(std::move(node_ref));
       }
     }
   }
@@ -120,15 +122,16 @@ std::string ChannelzRegistry::InternalGetTopChannels(
 }
 
 std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
-  InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
+  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
     for (auto it = node_map_.lower_bound(start_server_id);
          it != node_map_.end(); ++it) {
       BaseNode* node = it->second;
+      RefCountedPtr<BaseNode> node_ref;
       if (node->type() == BaseNode::EntityType::kServer &&
-          node->RefIfNonZero()) {
+          (node_ref = node->RefIfNonZero()) != nullptr) {
         // Check if we are over pagination limit to determine if we need to set
         // the "end" element. If we don't go through this block, we know that
         // when the loop terminates, we have <= to kPaginationLimit.
@@ -136,10 +139,10 @@ std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
         // refcount, we need to decrease it, but we can't unref while
         // holding the lock, because this may lead to a deadlock.
         if (servers.size() == kPaginationLimit) {
-          node_after_pagination_limit.reset(node);
+          node_after_pagination_limit = std::move(node_ref);
           break;
         }
-        servers.emplace_back(node);
+        servers.emplace_back(std::move(node_ref));
       }
     }
   }
@@ -158,13 +161,13 @@ std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
 }
 
 void ChannelzRegistry::InternalLogAllEntities() {
-  InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
+  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
   {
     MutexLock lock(&mu_);
     for (auto& p : node_map_) {
-      BaseNode* node = p.second;
-      if (node->RefIfNonZero()) {
-        nodes.emplace_back(node);
+      RefCountedPtr<BaseNode> node = p.second->RefIfNonZero();
+      if (node != nullptr) {
+        nodes.emplace_back(std::move(node));
       }
     }
   }
@@ -178,18 +181,24 @@ void ChannelzRegistry::InternalLogAllEntities() {
 }  // namespace grpc_core
 
 char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   return gpr_strdup(
       grpc_core::channelz::ChannelzRegistry::GetTopChannels(start_channel_id)
           .c_str());
 }
 
 char* grpc_channelz_get_servers(intptr_t start_server_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   return gpr_strdup(
       grpc_core::channelz::ChannelzRegistry::GetServers(start_server_id)
           .c_str());
 }
 
 char* grpc_channelz_get_server(intptr_t server_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> server_node =
       grpc_core::channelz::ChannelzRegistry::Get(server_id);
   if (server_node == nullptr ||
@@ -206,10 +215,14 @@ char* grpc_channelz_get_server(intptr_t server_id) {
 char* grpc_channelz_get_server_sockets(intptr_t server_id,
                                        intptr_t start_socket_id,
                                        intptr_t max_results) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
+  // Validate inputs before handing them of to the renderer.
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> base_node =
       grpc_core::channelz::ChannelzRegistry::Get(server_id);
   if (base_node == nullptr ||
-      base_node->type() != grpc_core::channelz::BaseNode::EntityType::kServer) {
+      base_node->type() != grpc_core::channelz::BaseNode::EntityType::kServer ||
+      start_socket_id < 0 || max_results < 0) {
     return nullptr;
   }
   // This cast is ok since we have just checked to make sure base_node is
@@ -221,6 +234,8 @@ char* grpc_channelz_get_server_sockets(intptr_t server_id,
 }
 
 char* grpc_channelz_get_channel(intptr_t channel_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> channel_node =
       grpc_core::channelz::ChannelzRegistry::Get(channel_id);
   if (channel_node == nullptr ||
@@ -237,6 +252,8 @@ char* grpc_channelz_get_channel(intptr_t channel_id) {
 }
 
 char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> subchannel_node =
       grpc_core::channelz::ChannelzRegistry::Get(subchannel_id);
   if (subchannel_node == nullptr ||
@@ -251,6 +268,8 @@ char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
 }
 
 char* grpc_channelz_get_socket(intptr_t socket_id) {
+  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+  grpc_core::ExecCtx exec_ctx;
   grpc_core::RefCountedPtr<grpc_core::channelz::BaseNode> socket_node =
       grpc_core::channelz::ChannelzRegistry::Get(socket_id);
   if (socket_node == nullptr ||

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

@@ -23,9 +23,11 @@
 
 #include <stdint.h>
 
+#include <map>
+#include <string>
+
 #include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/channelz.h"
-#include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_core {

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

@@ -38,13 +38,12 @@ typedef struct connected_channel_channel_data {
   grpc_transport* transport;
 } channel_data;
 
-typedef struct {
+struct callback_state {
   grpc_closure closure;
   grpc_closure* original_closure;
   grpc_core::CallCombiner* call_combiner;
   const char* reason;
-} callback_state;
-
+};
 typedef struct connected_channel_call_data {
   grpc_core::CallCombiner* call_combiner;
   // Closures used for returning results on the call combiner.
@@ -91,9 +90,12 @@ static callback_state* get_state_for_batch(
 /* We perform a small hack to locate transport data alongside the connected
    channel data in call allocations, to allow everything to be pulled in minimal
    cache line requests */
-#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) ((grpc_stream*)((calld) + 1))
+#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) \
+  ((grpc_stream*)(((char*)(calld)) +           \
+                  GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(call_data))))
 #define CALL_DATA_FROM_TRANSPORT_STREAM(transport_stream) \
-  (((call_data*)(transport_stream)) - 1)
+  ((call_data*)(((char*)(transport_stream)) -             \
+                GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(call_data))))
 
 /* Intercept a call operation and either push it directly up or translate it
    into transport stream operations */

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

@@ -35,7 +35,7 @@ typedef enum {
   /// Reserved for traffic_class_context.
   GRPC_CONTEXT_TRAFFIC,
 
-  /// Holds a pointer to ServiceConfig::CallData associated with this call.
+  /// Holds a pointer to ServiceConfigCallData associated with this call.
   GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA,
 
   GRPC_CONTEXT_COUNT

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

@@ -20,6 +20,8 @@
 
 #include <string.h>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/impl/codegen/slice.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -37,62 +39,21 @@ TraceFlag grpc_handshaker_trace(false, "handshaker");
 
 namespace {
 
-char* HandshakerArgsString(HandshakerArgs* args) {
-  char* args_str = grpc_channel_args_string(args->args);
+std::string HandshakerArgsString(HandshakerArgs* args) {
   size_t num_args = args->args != nullptr ? args->args->num_args : 0;
   size_t read_buffer_length =
       args->read_buffer != nullptr ? args->read_buffer->length : 0;
-  char* str;
-  gpr_asprintf(&str,
-               "{endpoint=%p, args=%p {size=%" PRIuPTR
-               ": %s}, read_buffer=%p (length=%" PRIuPTR "), exit_early=%d}",
-               args->endpoint, args->args, num_args, args_str,
-               args->read_buffer, read_buffer_length, args->exit_early);
-  gpr_free(args_str);
-  return str;
+  return absl::StrFormat(
+      "{endpoint=%p, args=%p {size=%" PRIuPTR
+      ": %s}, read_buffer=%p (length=%" PRIuPTR "), exit_early=%d}",
+      args->endpoint, args->args, num_args,
+      grpc_channel_args_string(args->args), args->read_buffer,
+      read_buffer_length, args->exit_early);
 }
 
 }  // namespace
 
-HandshakeManager::HandshakeManager() { gpr_mu_init(&mu_); }
-
-/// Add \a mgr to the server side list of all pending handshake managers, the
-/// list starts with \a *head.
-// Not thread-safe. Caller needs to synchronize.
-void HandshakeManager::AddToPendingMgrList(HandshakeManager** head) {
-  GPR_ASSERT(prev_ == nullptr);
-  GPR_ASSERT(next_ == nullptr);
-  next_ = *head;
-  if (*head) {
-    (*head)->prev_ = this;
-  }
-  *head = this;
-}
-
-/// Remove \a mgr from the server side list of all pending handshake managers.
-// Not thread-safe. Caller needs to synchronize.
-void HandshakeManager::RemoveFromPendingMgrList(HandshakeManager** head) {
-  if (next_ != nullptr) {
-    next_->prev_ = prev_;
-  }
-  if (prev_ != nullptr) {
-    prev_->next_ = next_;
-  } else {
-    GPR_ASSERT(*head == this);
-    *head = next_;
-  }
-}
-
-/// Shutdown all pending handshake managers starting at head on the server
-/// side. Not thread-safe. Caller needs to synchronize.
-void HandshakeManager::ShutdownAllPending(grpc_error* why) {
-  auto* head = this;
-  while (head != nullptr) {
-    head->Shutdown(GRPC_ERROR_REF(why));
-    head = head->next_;
-  }
-  GRPC_ERROR_UNREF(why);
-}
+HandshakeManager::HandshakeManager() {}
 
 void HandshakeManager::Add(RefCountedPtr<Handshaker> handshaker) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
@@ -105,10 +66,7 @@ void HandshakeManager::Add(RefCountedPtr<Handshaker> handshaker) {
   handshakers_.push_back(std::move(handshaker));
 }
 
-HandshakeManager::~HandshakeManager() {
-  handshakers_.clear();
-  gpr_mu_destroy(&mu_);
-}
+HandshakeManager::~HandshakeManager() { handshakers_.clear(); }
 
 void HandshakeManager::Shutdown(grpc_error* why) {
   {
@@ -127,12 +85,11 @@ void HandshakeManager::Shutdown(grpc_error* why) {
 // Returns true if we've scheduled the on_handshake_done callback.
 bool HandshakeManager::CallNextHandshakerLocked(grpc_error* error) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_handshaker_trace)) {
-    char* args_str = HandshakerArgsString(&args_);
     gpr_log(GPR_INFO,
             "handshake_manager %p: error=%s shutdown=%d index=%" PRIuPTR
             ", args=%s",
-            this, grpc_error_string(error), is_shutdown_, index_, args_str);
-    gpr_free(args_str);
+            this, grpc_error_string(error), is_shutdown_, index_,
+            HandshakerArgsString(&args_).c_str());
   }
   GPR_ASSERT(index_ <= handshakers_.size());
   // If we got an error or we've been shut down or we're exiting early or
@@ -218,7 +175,6 @@ void HandshakeManager::DoHandshake(grpc_endpoint* endpoint,
   {
     MutexLock lock(&mu_);
     GPR_ASSERT(index_ == 0);
-    GPR_ASSERT(!is_shutdown_);
     // Construct handshaker args.  These will be passed through all
     // handshakers and eventually be freed by the on_handshake_done callback.
     args_.endpoint = endpoint;
@@ -258,7 +214,7 @@ void HandshakeManager::DoHandshake(grpc_endpoint* endpoint,
 void grpc_handshake_manager_add(grpc_handshake_manager* mgr,
                                 grpc_handshaker* handshaker) {
   // This is a transition method to aid the API change for handshakers.
-  using namespace grpc_core;
-  RefCountedPtr<Handshaker> refd_hs(static_cast<Handshaker*>(handshaker));
+  grpc_core::RefCountedPtr<grpc_core::Handshaker> refd_hs(
+      static_cast<grpc_core::Handshaker*>(handshaker));
   mgr->Add(refd_hs);
 }