grpc 1.27.0.pre1 → 1.30.1

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

@@ -25,10 +25,11 @@
 
 #include <string>
 
+#include "absl/container/inlined_vector.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"
@@ -91,11 +92,11 @@ class BaseNode : public RefCounted {
   virtual ~BaseNode();
 
   // All children must implement this function.
-  virtual grpc_json* RenderJson() = 0;
+  virtual Json RenderJson() = 0;
 
   // Renders the json and returns allocated string that must be freed by the
   // caller.
-  char* RenderJsonString();
+  std::string RenderJsonString();
 
   EntityType type() const { return type_; }
   intptr_t uuid() const { return uuid_; }
@@ -124,7 +125,7 @@ class CallCountingHelper {
   void RecordCallSucceeded();
 
   // Common rendering of the call count data and last_call_started_timestamp.
-  void PopulateCallCounts(grpc_json* json);
+  void PopulateCallCounts(Json::Object* json);
 
  private:
   // testing peer friend.
@@ -148,17 +149,13 @@ class CallCountingHelper {
     // Make sure the size is exactly one cache line.
     uint8_t padding[GPR_CACHELINE_SIZE - 3 * sizeof(Atomic<intptr_t>) -
                     sizeof(Atomic<gpr_cycle_counter>)];
-  }
-#if GRPC_USE_ABSL
+  };
   // TODO(soheilhy,veblush): Revist this after abseil integration.
   // This has a problem when using abseil inlined_vector because it
   // carries an alignment attribute properly but our allocator doesn't
   // respect this. To avoid UBSAN errors, this should be removed with
   // abseil inlined_vector.
-  ;
-#else
-  GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
-#endif
+  // GPR_ALIGN_STRUCT(GPR_CACHELINE_SIZE);
 
   struct CounterData {
     int64_t calls_started = 0;
@@ -171,7 +168,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;
 };
 
@@ -187,7 +184,7 @@ class ChannelNode : public BaseNode {
 
   intptr_t parent_uuid() const { return parent_uuid_; }
 
-  grpc_json* RenderJson() override;
+  Json RenderJson() override;
 
   // proxy methods to composed classes.
   void AddTraceEvent(ChannelTrace::Severity severity, const grpc_slice& data) {
@@ -216,7 +213,7 @@ class ChannelNode : public BaseNode {
   void RemoveChildSubchannel(intptr_t child_uuid);
 
  private:
-  void PopulateChildRefs(grpc_json* json);
+  void PopulateChildRefs(Json::Object* json);
 
   // to allow the channel trace test to access trace_.
   friend class testing::ChannelNodePeer;
@@ -245,9 +242,10 @@ class ServerNode : public BaseNode {
 
   ~ServerNode() override;
 
-  grpc_json* RenderJson() override;
+  Json RenderJson() override;
 
-  char* RenderServerSockets(intptr_t start_socket_id, intptr_t max_results);
+  std::string RenderServerSockets(intptr_t start_socket_id,
+                                  intptr_t max_results);
 
   void AddChildSocket(RefCountedPtr<SocketNode> node);
 
@@ -285,7 +283,7 @@ class SocketNode : public BaseNode {
   SocketNode(std::string local, std::string remote, std::string name);
   ~SocketNode() override {}
 
-  grpc_json* RenderJson() override;
+  Json RenderJson() override;
 
   void RecordStreamStartedFromLocal();
   void RecordStreamStartedFromRemote();
@@ -324,7 +322,7 @@ class ListenSocketNode : public BaseNode {
   ListenSocketNode(std::string local_addr, std::string name);
   ~ListenSocketNode() override {}
 
-  grpc_json* RenderJson() override;
+  Json RenderJson() override;
 
  private:
   std::string local_addr_;

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"
@@ -30,6 +32,7 @@
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
 namespace grpc_core {
@@ -79,11 +82,9 @@ RefCountedPtr ChannelzRegistry::InternalGet(intptr_t uuid) {
   return RefCountedPtr<BaseNode>(node);
 }
 
-char* ChannelzRegistry::InternalGetTopChannels(intptr_t start_channel_id) {
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* json_iterator = nullptr;
-  InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
+std::string ChannelzRegistry::InternalGetTopChannels(
+    intptr_t start_channel_id) {
+  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> top_level_channels;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
@@ -106,30 +107,22 @@ char* ChannelzRegistry::InternalGetTopChannels(intptr_t start_channel_id) {
       }
     }
   }
+  Json::Object object;
   if (!top_level_channels.empty()) {
-    // create list of channels
-    grpc_json* array_parent = grpc_json_create_child(
-        nullptr, json, "channel", nullptr, GRPC_JSON_ARRAY, false);
+    // Create list of channels.
+    Json::Array array;
     for (size_t i = 0; i < top_level_channels.size(); ++i) {
-      grpc_json* channel_json = top_level_channels[i]->RenderJson();
-      json_iterator =
-          grpc_json_link_child(array_parent, channel_json, json_iterator);
+      array.emplace_back(top_level_channels[i]->RenderJson());
     }
+    object["channel"] = std::move(array);
   }
-  if (node_after_pagination_limit == nullptr) {
-    grpc_json_create_child(nullptr, json, "end", nullptr, GRPC_JSON_TRUE,
-                           false);
-  }
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  if (node_after_pagination_limit == nullptr) object["end"] = true;
+  Json json(std::move(object));
+  return json.Dump();
 }
 
-char* ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* json_iterator = nullptr;
-  InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
+std::string ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
+  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> servers;
   RefCountedPtr<BaseNode> node_after_pagination_limit;
   {
     MutexLock lock(&mu_);
@@ -152,27 +145,22 @@ char* ChannelzRegistry::InternalGetServers(intptr_t start_server_id) {
       }
     }
   }
+  Json::Object object;
   if (!servers.empty()) {
-    // create list of servers
-    grpc_json* array_parent = grpc_json_create_child(
-        nullptr, json, "server", nullptr, GRPC_JSON_ARRAY, false);
+    // Create list of servers.
+    Json::Array array;
     for (size_t i = 0; i < servers.size(); ++i) {
-      grpc_json* server_json = servers[i]->RenderJson();
-      json_iterator =
-          grpc_json_link_child(array_parent, server_json, json_iterator);
+      array.emplace_back(servers[i]->RenderJson());
     }
+    object["server"] = std::move(array);
   }
-  if (node_after_pagination_limit == nullptr) {
-    grpc_json_create_child(nullptr, json, "end", nullptr, GRPC_JSON_TRUE,
-                           false);
-  }
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  if (node_after_pagination_limit == nullptr) object["end"] = true;
+  Json json(std::move(object));
+  return json.Dump();
 }
 
 void ChannelzRegistry::InternalLogAllEntities() {
-  InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
+  absl::InlinedVector<RefCountedPtr<BaseNode>, 10> nodes;
   {
     MutexLock lock(&mu_);
     for (auto& p : node_map_) {
@@ -183,9 +171,8 @@ void ChannelzRegistry::InternalLogAllEntities() {
     }
   }
   for (size_t i = 0; i < nodes.size(); ++i) {
-    char* json = nodes[i]->RenderJsonString();
-    gpr_log(GPR_INFO, "%s", json);
-    gpr_free(json);
+    std::string json = nodes[i]->RenderJsonString();
+    gpr_log(GPR_INFO, "%s", json.c_str());
   }
 }
 
@@ -193,12 +180,15 @@ void ChannelzRegistry::InternalLogAllEntities() {
 }  // namespace grpc_core
 
 char* grpc_channelz_get_top_channels(intptr_t start_channel_id) {
-  return grpc_core::channelz::ChannelzRegistry::GetTopChannels(
-      start_channel_id);
+  return gpr_strdup(
+      grpc_core::channelz::ChannelzRegistry::GetTopChannels(start_channel_id)
+          .c_str());
 }
 
 char* grpc_channelz_get_servers(intptr_t start_server_id) {
-  return grpc_core::channelz::ChannelzRegistry::GetServers(start_server_id);
+  return gpr_strdup(
+      grpc_core::channelz::ChannelzRegistry::GetServers(start_server_id)
+          .c_str());
 }
 
 char* grpc_channelz_get_server(intptr_t server_id) {
@@ -209,14 +199,10 @@ char* grpc_channelz_get_server(intptr_t server_id) {
           grpc_core::channelz::BaseNode::EntityType::kServer) {
     return nullptr;
   }
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* channel_json = server_node->RenderJson();
-  channel_json->key = "server";
-  grpc_json_link_child(json, channel_json, nullptr);
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  grpc_core::Json json = grpc_core::Json::Object{
+      {"server", server_node->RenderJson()},
+  };
+  return gpr_strdup(json.Dump().c_str());
 }
 
 char* grpc_channelz_get_server_sockets(intptr_t server_id,
@@ -229,10 +215,11 @@ char* grpc_channelz_get_server_sockets(intptr_t server_id,
     return nullptr;
   }
   // This cast is ok since we have just checked to make sure base_node is
-  // actually a server node
+  // actually a server node.
   grpc_core::channelz::ServerNode* server_node =
       static_cast<grpc_core::channelz::ServerNode*>(base_node.get());
-  return server_node->RenderServerSockets(start_socket_id, max_results);
+  return gpr_strdup(
+      server_node->RenderServerSockets(start_socket_id, max_results).c_str());
 }
 
 char* grpc_channelz_get_channel(intptr_t channel_id) {
@@ -245,14 +232,10 @@ char* grpc_channelz_get_channel(intptr_t channel_id) {
            grpc_core::channelz::BaseNode::EntityType::kInternalChannel)) {
     return nullptr;
   }
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* channel_json = channel_node->RenderJson();
-  channel_json->key = "channel";
-  grpc_json_link_child(json, channel_json, nullptr);
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  grpc_core::Json json = grpc_core::Json::Object{
+      {"channel", channel_node->RenderJson()},
+  };
+  return gpr_strdup(json.Dump().c_str());
 }
 
 char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
@@ -263,14 +246,10 @@ char* grpc_channelz_get_subchannel(intptr_t subchannel_id) {
           grpc_core::channelz::BaseNode::EntityType::kSubchannel) {
     return nullptr;
   }
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* subchannel_json = subchannel_node->RenderJson();
-  subchannel_json->key = "subchannel";
-  grpc_json_link_child(json, subchannel_json, nullptr);
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  grpc_core::Json json = grpc_core::Json::Object{
+      {"subchannel", subchannel_node->RenderJson()},
+  };
+  return gpr_strdup(json.Dump().c_str());
 }
 
 char* grpc_channelz_get_socket(intptr_t socket_id) {
@@ -281,12 +260,8 @@ char* grpc_channelz_get_socket(intptr_t socket_id) {
           grpc_core::channelz::BaseNode::EntityType::kSocket) {
     return nullptr;
   }
-  grpc_json* top_level_json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json* json = top_level_json;
-  grpc_json* socket_json = socket_node->RenderJson();
-  socket_json->key = "socket";
-  grpc_json_link_child(json, socket_json, nullptr);
-  char* json_str = grpc_json_dump_to_string(top_level_json, 0);
-  grpc_json_destroy(top_level_json);
-  return json_str;
+  grpc_core::Json json = grpc_core::Json::Object{
+      {"socket", socket_node->RenderJson()},
+  };
+  return gpr_strdup(json.Dump().c_str());
 }

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

@@ -51,13 +51,13 @@ class ChannelzRegistry {
 
   // Returns the allocated JSON string that represents the proto
   // GetTopChannelsResponse as per channelz.proto.
-  static char* GetTopChannels(intptr_t start_channel_id) {
+  static std::string GetTopChannels(intptr_t start_channel_id) {
     return Default()->InternalGetTopChannels(start_channel_id);
   }
 
   // Returns the allocated JSON string that represents the proto
   // GetServersResponse as per channelz.proto.
-  static char* GetServers(intptr_t start_server_id) {
+  static std::string GetServers(intptr_t start_server_id) {
     return Default()->InternalGetServers(start_server_id);
   }
 
@@ -80,8 +80,8 @@ class ChannelzRegistry {
   // returns the void* associated with that uuid. Else returns nullptr.
   RefCountedPtr<BaseNode> InternalGet(intptr_t uuid);
 
-  char* InternalGetTopChannels(intptr_t start_channel_id);
-  char* InternalGetServers(intptr_t start_server_id);
+  std::string InternalGetTopChannels(intptr_t start_channel_id);
+  std::string InternalGetServers(intptr_t start_server_id);
 
   void InternalLogAllEntities();
 

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,19 +39,16 @@ 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
@@ -127,12 +126,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