grpc 1.21.0 → 1.22.0

data/src/core/ext/transport/chttp2/transport/hpack_parser.cc

@@ -35,6 +35,7 @@
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/http2_errors.h"
 
 typedef enum {
@@ -627,7 +628,7 @@ static grpc_error* on_hdr(grpc_chttp2_hpack_parser* p, grpc_mdelem md,
   if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
     char* k = grpc_slice_to_c_string(GRPC_MDKEY(md));
     char* v = nullptr;
-    if (grpc_is_binary_header(GRPC_MDKEY(md))) {
+    if (grpc_is_binary_header_internal(GRPC_MDKEY(md))) {
       v = grpc_dump_slice(GRPC_MDVALUE(md), GPR_DUMP_HEX);
     } else {
       v = grpc_slice_to_c_string(GRPC_MDVALUE(md));
@@ -1494,7 +1495,13 @@ static grpc_error* parse_key_string(grpc_chttp2_hpack_parser* p,
 /* check if a key represents a binary header or not */
 
 static bool is_binary_literal_header(grpc_chttp2_hpack_parser* p) {
-  return grpc_is_binary_header(
+  /* We know that either argument here is a reference counter slice.
+   * 1. If a result of grpc_slice_from_static_buffer, the refcount is set to
+   *    NoopRefcount.
+   * 2. If it's p->key.data.referenced, then p->key.copied was set to false,
+   *    which occurs in begin_parse_string() - where the refcount is set to
+   *    p->current_slice_refcount, which is not null. */
+  return grpc_is_refcounted_slice_binary_header(
       p->key.copied ? grpc_slice_from_static_buffer(p->key.data.copied.str,
                                                     p->key.data.copied.length)
                     : p->key.data.referenced);
@@ -1511,7 +1518,15 @@ static grpc_error* is_binary_indexed_header(grpc_chttp2_hpack_parser* p,
                            static_cast<intptr_t>(p->index)),
         GRPC_ERROR_INT_SIZE, static_cast<intptr_t>(p->table.num_ents));
   }
-  *is = grpc_is_binary_header(GRPC_MDKEY(elem));
+  /* We know that GRPC_MDKEY(elem) points to a reference counted slice since:
+   * 1. elem was a result of grpc_chttp2_hptbl_lookup
+   * 2. An item in this table is either static (see entries with
+   *    index < GRPC_CHTTP2_LAST_STATIC_ENTRY or added via
+   *    grpc_chttp2_hptbl_add).
+   * 3. If added via grpc_chttp2_hptbl_add, the entry is either static or
+   *    interned.
+   * 4. Both static and interned element slices have non-null refcounts. */
+  *is = grpc_is_refcounted_slice_binary_header(GRPC_MDKEY(elem));
   return GRPC_ERROR_NONE;
 }
 

data/src/core/ext/transport/chttp2/transport/hpack_table.cc

@@ -29,6 +29,7 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/murmur_hash.h"
+#include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/static_metadata.h"
 
 extern grpc_core::TraceFlag grpc_http_trace;
@@ -375,9 +376,11 @@ static size_t get_base64_encoded_size(size_t raw_length) {
 
 size_t grpc_chttp2_get_size_in_hpack_table(grpc_mdelem elem,
                                            bool use_true_binary_metadata) {
-  size_t overhead_and_key = 32 + GRPC_SLICE_LENGTH(GRPC_MDKEY(elem));
+  const uint8_t* key_buf = GRPC_SLICE_START_PTR(GRPC_MDKEY(elem));
+  size_t key_len = GRPC_SLICE_LENGTH(GRPC_MDKEY(elem));
+  size_t overhead_and_key = 32 + key_len;
   size_t value_len = GRPC_SLICE_LENGTH(GRPC_MDVALUE(elem));
-  if (grpc_is_binary_header(GRPC_MDKEY(elem))) {
+  if (grpc_key_is_binary_header(key_buf, key_len)) {
     return overhead_and_key + (use_true_binary_metadata
                                    ? value_len + 1
                                    : get_base64_encoded_size(value_len));
@@ -385,13 +388,3 @@ size_t grpc_chttp2_get_size_in_hpack_table(grpc_mdelem elem,
     return overhead_and_key + value_len;
   }
 }
-
-uint8_t grpc_chttp2_get_static_hpack_table_index(grpc_mdelem md) {
-  if (GRPC_MDELEM_STORAGE(md) == GRPC_MDELEM_STORAGE_STATIC) {
-    uint8_t index = GRPC_MDELEM_DATA(md) - grpc_static_mdelem_table;
-    if (index < GRPC_CHTTP2_LAST_STATIC_ENTRY) {
-      return index + 1;  // Hpack static metadata element indices start at 1
-    }
-  }
-  return 0;
-}

data/src/core/ext/transport/chttp2/transport/hpack_table.h

@@ -24,6 +24,7 @@
 #include <grpc/slice.h>
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/metadata.h"
+#include "src/core/lib/transport/static_metadata.h"
 
 /* HPACK header table */
 
@@ -90,7 +91,15 @@ size_t grpc_chttp2_get_size_in_hpack_table(grpc_mdelem elem,
 /* Returns the static hpack table index that corresponds to /a elem. Returns 0
   if /a elem is not statically stored or if it is not in the static hpack
   table */
-uint8_t grpc_chttp2_get_static_hpack_table_index(grpc_mdelem md);
+inline uintptr_t grpc_chttp2_get_static_hpack_table_index(grpc_mdelem md) {
+  uintptr_t index =
+      reinterpret_cast<grpc_core::StaticMetadata*>(GRPC_MDELEM_DATA(md)) -
+      grpc_static_mdelem_table;
+  if (index < GRPC_CHTTP2_LAST_STATIC_ENTRY) {
+    return index + 1;  // Hpack static metadata element indices start at 1
+  }
+  return 0;
+}
 
 /* Find a key/value pair in the table... returns the index in the table of the
    most similar entry, or 0 if the value was not found */

data/src/core/ext/transport/chttp2/transport/internal.h

@@ -225,14 +225,14 @@ class Chttp2IncomingByteStream : public ByteStream {
   // TODO(roth): When I converted this class to C++, I wanted to make it
   // inherit from RefCounted or InternallyRefCounted instead of continuing
   // to use its own custom ref-counting code.  However, that would require
-  // using multiple inheritence, which sucks in general.  And to make matters
+  // using multiple inheritance, which sucks in general.  And to make matters
   // worse, it causes problems with our New<> and Delete<> wrappers.
   // Specifically, unless RefCounted is first in the list of parent classes,
   // it will see a different value of the address of the object than the one
   // we actually allocated, in which case gpr_free() will be called on a
   // different address than the one we got from gpr_malloc(), thus causing a
   // crash.  Given the fragility of depending on that, as well as a desire to
-  // avoid multiple inheritence in general, I've decided to leave this
+  // avoid multiple inheritance in general, I've decided to leave this
   // alone for now.  We can revisit this once we're able to link against
   // libc++, at which point we can eliminate New<> and Delete<> and
   // switch to std::shared_ptr<>.
@@ -499,7 +499,7 @@ typedef enum {
   GRPC_METADATA_NOT_PUBLISHED,
   GRPC_METADATA_SYNTHESIZED_FROM_FAKE,
   GRPC_METADATA_PUBLISHED_FROM_WIRE,
-  GPRC_METADATA_PUBLISHED_AT_CLOSE
+  GRPC_METADATA_PUBLISHED_AT_CLOSE
 } grpc_published_metadata_method;
 
 struct grpc_chttp2_stream {

data/src/core/ext/transport/chttp2/transport/parsing.cc

@@ -28,6 +28,7 @@
 
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/transport/http2_errors.h"
 #include "src/core/lib/transport/static_metadata.h"
 #include "src/core/lib/transport/status_conversion.h"
@@ -410,53 +411,42 @@ static void on_initial_header(void* tp, grpc_mdelem md) {
     gpr_free(value);
   }
 
-  if (GRPC_MDELEM_STORAGE(md) == GRPC_MDELEM_STORAGE_STATIC) {
-    // We don't use grpc_mdelem_eq here to avoid executing additional
-    // instructions. The reasoning is if the payload is not equal, we already
-    // know that the metadata elements are not equal because the md is
-    // confirmed to be static. If we had used grpc_mdelem_eq here, then if the
-    // payloads are not equal, grpc_mdelem_eq executes more instructions to
-    // determine if they're equal or not.
-    if (md.payload == GRPC_MDELEM_GRPC_STATUS_1.payload ||
-        md.payload == GRPC_MDELEM_GRPC_STATUS_2.payload) {
-      s->seen_error = true;
-    }
-  } else {
-    if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_STATUS) &&
-        !grpc_mdelem_eq(md, GRPC_MDELEM_GRPC_STATUS_0)) {
-      /* TODO(ctiller): check for a status like " 0" */
-      s->seen_error = true;
-    }
-
-    if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_TIMEOUT)) {
-      grpc_millis* cached_timeout = static_cast<grpc_millis*>(
-          grpc_mdelem_get_user_data(md, free_timeout));
-      grpc_millis timeout;
-      if (cached_timeout != nullptr) {
-        timeout = *cached_timeout;
-      } else {
-        if (GPR_UNLIKELY(
-                !grpc_http2_decode_timeout(GRPC_MDVALUE(md), &timeout))) {
-          char* val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
-          gpr_log(GPR_ERROR, "Ignoring bad timeout value '%s'", val);
-          gpr_free(val);
-          timeout = GRPC_MILLIS_INF_FUTURE;
-        }
-        if (GRPC_MDELEM_IS_INTERNED(md)) {
-          /* store the result */
-          cached_timeout =
-              static_cast<grpc_millis*>(gpr_malloc(sizeof(grpc_millis)));
-          *cached_timeout = timeout;
-          grpc_mdelem_set_user_data(md, free_timeout, cached_timeout);
-        }
+  // If md.payload == GRPC_MDELEM_GRPC_STATUS_1 or GRPC_MDELEM_GRPC_STATUS_2,
+  // then we have seen an error. In fact, if it is a GRPC_STATUS and it's
+  // not equal to GRPC_MDELEM_GRPC_STATUS_0, then we have seen an error.
+  if (grpc_slice_eq_static_interned(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_STATUS) &&
+      !grpc_mdelem_static_value_eq(md, GRPC_MDELEM_GRPC_STATUS_0)) {
+    /* TODO(ctiller): check for a status like " 0" */
+    s->seen_error = true;
+  } else if (grpc_slice_eq_static_interned(GRPC_MDKEY(md),
+                                           GRPC_MDSTR_GRPC_TIMEOUT)) {
+    grpc_millis* cached_timeout =
+        static_cast<grpc_millis*>(grpc_mdelem_get_user_data(md, free_timeout));
+    grpc_millis timeout;
+    if (cached_timeout != nullptr) {
+      timeout = *cached_timeout;
+    } else {
+      if (GPR_UNLIKELY(
+              !grpc_http2_decode_timeout(GRPC_MDVALUE(md), &timeout))) {
+        char* val = grpc_slice_to_c_string(GRPC_MDVALUE(md));
+        gpr_log(GPR_ERROR, "Ignoring bad timeout value '%s'", val);
+        gpr_free(val);
+        timeout = GRPC_MILLIS_INF_FUTURE;
       }
-      if (timeout != GRPC_MILLIS_INF_FUTURE) {
-        grpc_chttp2_incoming_metadata_buffer_set_deadline(
-            &s->metadata_buffer[0], grpc_core::ExecCtx::Get()->Now() + timeout);
+      if (GRPC_MDELEM_IS_INTERNED(md)) {
+        /* store the result */
+        cached_timeout =
+            static_cast<grpc_millis*>(gpr_malloc(sizeof(grpc_millis)));
+        *cached_timeout = timeout;
+        grpc_mdelem_set_user_data(md, free_timeout, cached_timeout);
       }
-      GRPC_MDELEM_UNREF(md);
-      return;
     }
+    if (timeout != GRPC_MILLIS_INF_FUTURE) {
+      grpc_chttp2_incoming_metadata_buffer_set_deadline(
+          &s->metadata_buffer[0], grpc_core::ExecCtx::Get()->Now() + timeout);
+    }
+    GRPC_MDELEM_UNREF(md);
+    return;
   }
 
   const size_t new_size = s->metadata_buffer[0].size + GRPC_MDELEM_LENGTH(md);
@@ -506,19 +496,11 @@ static void on_trailing_header(void* tp, grpc_mdelem md) {
     gpr_free(value);
   }
 
-  if (GRPC_MDELEM_STORAGE(md) == GRPC_MDELEM_STORAGE_STATIC) {
-    // We don't use grpc_mdelem_eq here to avoid executing additional
-    // instructions. The reasoning is if the payload is not equal, we already
-    // know that the metadata elements are not equal because the md is
-    // confirmed to be static. If we had used grpc_mdelem_eq here, then if the
-    // payloads are not equal, grpc_mdelem_eq executes more instructions to
-    // determine if they're equal or not.
-    if (md.payload == GRPC_MDELEM_GRPC_STATUS_1.payload ||
-        md.payload == GRPC_MDELEM_GRPC_STATUS_2.payload) {
-      s->seen_error = true;
-    }
-  } else if (grpc_slice_eq(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_STATUS) &&
-             !grpc_mdelem_eq(md, GRPC_MDELEM_GRPC_STATUS_0)) {
+  // If md.payload == GRPC_MDELEM_GRPC_STATUS_1 or GRPC_MDELEM_GRPC_STATUS_2,
+  // then we have seen an error. In fact, if it is a GRPC_STATUS and it's
+  // not equal to GRPC_MDELEM_GRPC_STATUS_0, then we have seen an error.
+  if (grpc_slice_eq_static_interned(GRPC_MDKEY(md), GRPC_MDSTR_GRPC_STATUS) &&
+      !grpc_mdelem_static_value_eq(md, GRPC_MDELEM_GRPC_STATUS_0)) {
     /* TODO(ctiller): check for a status like " 0" */
     s->seen_error = true;
   }

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

@@ -40,12 +40,51 @@
 #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/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 namespace channelz {
 
+//
+// channel arg code
+//
+
+namespace {
+
+void* parent_uuid_copy(void* p) { return p; }
+void parent_uuid_destroy(void* p) {}
+int parent_uuid_cmp(void* p1, void* p2) { return GPR_ICMP(p1, p2); }
+const grpc_arg_pointer_vtable parent_uuid_vtable = {
+    parent_uuid_copy, parent_uuid_destroy, parent_uuid_cmp};
+
+}  // namespace
+
+grpc_arg MakeParentUuidArg(intptr_t parent_uuid) {
+  // We would ideally like to store the uuid in an integer argument.
+  // Unfortunately, that won't work, because intptr_t (the type used for
+  // uuids) doesn't fit in an int (the type used for integer args).
+  // So instead, we use a hack to store it as a pointer, because
+  // intptr_t should be the same size as void*.
+  static_assert(sizeof(intptr_t) <= sizeof(void*),
+                "can't fit intptr_t inside of void*");
+  return grpc_channel_arg_pointer_create(
+      const_cast<char*>(GRPC_ARG_CHANNELZ_PARENT_UUID),
+      reinterpret_cast<void*>(parent_uuid), &parent_uuid_vtable);
+}
+
+intptr_t GetParentUuidFromArgs(const grpc_channel_args& args) {
+  const grpc_arg* arg =
+      grpc_channel_args_find(&args, GRPC_ARG_CHANNELZ_PARENT_UUID);
+  if (arg == nullptr || arg->type != GRPC_ARG_POINTER) return 0;
+  return reinterpret_cast<intptr_t>(arg->value.pointer.p);
+}
+
+//
+// BaseNode
+//
+
 BaseNode::BaseNode(EntityType type) : type_(type), uuid_(-1) {
   // The registry will set uuid_ under its lock.
   ChannelzRegistry::Register(this);
@@ -61,6 +100,10 @@ char* BaseNode::RenderJsonString() {
   return json_str;
 }
 
+//
+// CallCountingHelper
+//
+
 CallCountingHelper::CallCountingHelper() {
   num_cores_ = GPR_MAX(1, gpr_cpu_num_cores());
   per_cpu_counter_data_storage_ = static_cast<AtomicCounterData*>(
@@ -137,15 +180,17 @@ void CallCountingHelper::PopulateCallCounts(grpc_json* json) {
   }
 }
 
-ChannelNode::ChannelNode(grpc_channel* channel, size_t channel_tracer_max_nodes,
-                         bool is_top_level_channel)
-    : BaseNode(is_top_level_channel ? EntityType::kTopLevelChannel
-                                    : EntityType::kInternalChannel),
-      channel_(channel),
-      target_(UniquePtr<char>(grpc_channel_get_target(channel_))),
-      trace_(channel_tracer_max_nodes) {}
+//
+// ChannelNode
+//
 
-ChannelNode::~ChannelNode() {}
+ChannelNode::ChannelNode(UniquePtr<char> target,
+                         size_t channel_tracer_max_nodes, intptr_t parent_uuid)
+    : BaseNode(parent_uuid == 0 ? EntityType::kTopLevelChannel
+                                : EntityType::kInternalChannel),
+      target_(std::move(target)),
+      trace_(channel_tracer_max_nodes),
+      parent_uuid_(parent_uuid) {}
 
 grpc_json* ChannelNode::RenderJson() {
   // We need to track these three json objects to build our object
@@ -167,9 +212,19 @@ grpc_json* ChannelNode::RenderJson() {
                                            GRPC_JSON_OBJECT, false);
   json = data;
   json_iterator = nullptr;
-  // template method. Child classes may override this to add their specific
-  // functionality.
-  PopulateConnectivityState(json);
+  // connectivity state
+  // If low-order bit is on, then the field is set.
+  int state_field = connectivity_state_.Load(MemoryOrder::RELAXED);
+  if ((state_field & 1) != 0) {
+    grpc_connectivity_state state =
+        static_cast<grpc_connectivity_state>(state_field >> 1);
+    json = grpc_json_create_child(nullptr, json, "state", nullptr,
+                                  GRPC_JSON_OBJECT, false);
+    grpc_json_create_child(nullptr, json, "state",
+                           grpc_connectivity_state_name(state),
+                           GRPC_JSON_STRING, false);
+    json = data;
+  }
   // populate the target.
   GPR_ASSERT(target_.get() != nullptr);
   grpc_json_create_child(nullptr, json, "target", target_.get(),
@@ -189,13 +244,64 @@ grpc_json* ChannelNode::RenderJson() {
   return top_level_json;
 }
 
-RefCountedPtr<ChannelNode> ChannelNode::MakeChannelNode(
-    grpc_channel* channel, size_t channel_tracer_max_nodes,
-    bool is_top_level_channel) {
-  return MakeRefCounted<grpc_core::channelz::ChannelNode>(
-      channel, channel_tracer_max_nodes, is_top_level_channel);
+void ChannelNode::PopulateChildRefs(grpc_json* json) {
+  MutexLock lock(&child_mu_);
+  grpc_json* json_iterator = nullptr;
+  if (!child_subchannels_.empty()) {
+    grpc_json* array_parent = grpc_json_create_child(
+        nullptr, json, "subchannelRef", nullptr, GRPC_JSON_ARRAY, false);
+    for (const auto& p : child_subchannels_) {
+      json_iterator =
+          grpc_json_create_child(json_iterator, array_parent, nullptr, nullptr,
+                                 GRPC_JSON_OBJECT, false);
+      grpc_json_add_number_string_child(json_iterator, nullptr, "subchannelId",
+                                        p.first);
+    }
+  }
+  if (!child_channels_.empty()) {
+    grpc_json* array_parent = grpc_json_create_child(
+        nullptr, json, "channelRef", nullptr, GRPC_JSON_ARRAY, false);
+    json_iterator = nullptr;
+    for (const auto& p : child_channels_) {
+      json_iterator =
+          grpc_json_create_child(json_iterator, array_parent, nullptr, nullptr,
+                                 GRPC_JSON_OBJECT, false);
+      grpc_json_add_number_string_child(json_iterator, nullptr, "channelId",
+                                        p.first);
+    }
+  }
+}
+
+void ChannelNode::SetConnectivityState(grpc_connectivity_state state) {
+  // Store with low-order bit set to indicate that the field is set.
+  int state_field = (state << 1) + 1;
+  connectivity_state_.Store(state_field, MemoryOrder::RELAXED);
+}
+
+void ChannelNode::AddChildChannel(intptr_t child_uuid) {
+  MutexLock lock(&child_mu_);
+  child_channels_.insert(MakePair(child_uuid, true));
+}
+
+void ChannelNode::RemoveChildChannel(intptr_t child_uuid) {
+  MutexLock lock(&child_mu_);
+  child_channels_.erase(child_uuid);
 }
 
+void ChannelNode::AddChildSubchannel(intptr_t child_uuid) {
+  MutexLock lock(&child_mu_);
+  child_subchannels_.insert(MakePair(child_uuid, true));
+}
+
+void ChannelNode::RemoveChildSubchannel(intptr_t child_uuid) {
+  MutexLock lock(&child_mu_);
+  child_subchannels_.erase(child_uuid);
+}
+
+//
+// ServerNode
+//
+
 ServerNode::ServerNode(grpc_server* server, size_t channel_tracer_max_nodes)
     : BaseNode(EntityType::kServer),
       server_(server),
@@ -281,8 +387,14 @@ grpc_json* ServerNode::RenderJson() {
   return top_level_json;
 }
 
-static void PopulateSocketAddressJson(grpc_json* json, const char* name,
-                                      const char* addr_str) {
+//
+// SocketNode
+//
+
+namespace {
+
+void PopulateSocketAddressJson(grpc_json* json, const char* name,
+                               const char* addr_str) {
   if (addr_str == nullptr) return;
   grpc_json* json_iterator = nullptr;
   json_iterator = grpc_json_create_child(json_iterator, json, name, nullptr,
@@ -312,7 +424,6 @@ static void PopulateSocketAddressJson(grpc_json* json, const char* name,
                                            b64_host, GRPC_JSON_STRING, true);
     gpr_free(host);
     gpr_free(port);
-
   } else if (uri != nullptr && strcmp(uri->scheme, "unix") == 0) {
     json_iterator = grpc_json_create_child(json_iterator, json, "uds_address",
                                            nullptr, GRPC_JSON_OBJECT, false);
@@ -332,6 +443,8 @@ static void PopulateSocketAddressJson(grpc_json* json, const char* name,
   grpc_uri_destroy(uri);
 }
 
+}  // namespace
+
 SocketNode::SocketNode(UniquePtr<char> local, UniquePtr<char> remote)
     : BaseNode(EntityType::kSocket),
       local_(std::move(local)),
@@ -448,6 +561,10 @@ grpc_json* SocketNode::RenderJson() {
   return top_level_json;
 }
 
+//
+// ListenSocketNode
+//
+
 ListenSocketNode::ListenSocketNode(UniquePtr<char> local_addr)
     : BaseNode(EntityType::kSocket), local_addr_(std::move(local_addr)) {}