grpc 1.37.0.pre1 → 1.39.0.pre1

data/src/core/lib/event_engine/event_engine.cc

@@ -0,0 +1,50 @@
+// Copyright 2021 The 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/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/port.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/support/log.h>
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
+#include "src/core/lib/event_engine/sockaddr.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+EventEngine::ResolvedAddress::ResolvedAddress(const sockaddr* address,
+                                              socklen_t size)
+    : size_(size) {
+  GPR_ASSERT(size <= sizeof(address_));
+  memcpy(&address_, address, size);
+}
+
+const struct sockaddr* EventEngine::ResolvedAddress::address() const {
+  return reinterpret_cast<const struct sockaddr*>(address_);
+}
+
+socklen_t EventEngine::ResolvedAddress::size() const { return size_; }
+
+std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+DefaultEventEngineFactory() {
+  // TODO(nnoble): delete when uv-ee is merged
+  abort();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/slice_allocator.cc

@@ -0,0 +1,89 @@
+// Copyright 2021 The 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/event_engine/slice_allocator.h"
+
+#include <functional>
+
+#include "absl/status/status.h"
+
+#include "src/core/lib/iomgr/resource_quota.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+SliceAllocator::SliceAllocator(grpc_resource_user* user)
+    : resource_user_(user) {
+  grpc_resource_user_ref(resource_user_);
+};
+
+SliceAllocator::~SliceAllocator() {
+  if (resource_user_ != nullptr) {
+    grpc_resource_user_unref(resource_user_);
+  }
+};
+
+SliceAllocator::SliceAllocator(SliceAllocator&& other) noexcept
+    : resource_user_(other.resource_user_) {
+  other.resource_user_ = nullptr;
+}
+
+SliceAllocator& SliceAllocator::operator=(SliceAllocator&& other) noexcept {
+  resource_user_ = other.resource_user_;
+  other.resource_user_ = nullptr;
+  return *this;
+}
+
+absl::Status SliceAllocator::Allocate(size_t size, SliceBuffer* dest,
+                                      SliceAllocator::AllocateCallback cb) {
+  // TODO(hork): merge the implementation from the uv-ee branch.
+  (void)size;
+  (void)dest;
+  (void)cb;
+  return absl::OkStatus();
+};
+
+SliceAllocatorFactory::SliceAllocatorFactory(grpc_resource_quota* quota)
+    : resource_quota_(quota) {
+  grpc_resource_quota_ref_internal(resource_quota_);
+};
+
+SliceAllocatorFactory::~SliceAllocatorFactory() {
+  if (resource_quota_ != nullptr) {
+    grpc_resource_quota_unref_internal(resource_quota_);
+  }
+}
+
+SliceAllocatorFactory::SliceAllocatorFactory(
+    SliceAllocatorFactory&& other) noexcept
+    : resource_quota_(other.resource_quota_) {
+  other.resource_quota_ = nullptr;
+}
+
+SliceAllocatorFactory& SliceAllocatorFactory::operator=(
+    SliceAllocatorFactory&& other) noexcept {
+  resource_quota_ = other.resource_quota_;
+  other.resource_quota_ = nullptr;
+  return *this;
+}
+
+SliceAllocator SliceAllocatorFactory::CreateSliceAllocator(
+    absl::string_view peer_name) {
+  return SliceAllocator(
+      grpc_resource_user_create(resource_quota_, peer_name.data()));
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/sockaddr.cc

@@ -0,0 +1,40 @@
+// Copyright 2021 The 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>
+
+#ifdef GRPC_USE_EVENT_ENGINE
+#include <string.h>
+
+#include "grpc/event_engine/event_engine.h"
+#include "grpc/event_engine/port.h"
+#include "grpc/support/log.h"
+
+uint16_t grpc_htons(uint16_t hostshort) { return htons(hostshort); }
+
+uint16_t grpc_ntohs(uint16_t netshort) { return ntohs(netshort); }
+
+uint32_t grpc_htonl(uint32_t hostlong) { return htonl(hostlong); }
+
+uint32_t grpc_ntohl(uint32_t netlong) { return ntohl(netlong); }
+
+int grpc_inet_pton(int af, const char* src, void* dst) {
+  return inet_pton(af, src, dst);
+}
+
+const char* grpc_inet_ntop(int af, const void* src, char* dst, size_t size) {
+  inet_ntop(af, src, dst, size);
+  return dst;
+}
+
+#endif  // GRPC_USE_EVENT_ENGINE

data/src/core/lib/event_engine/sockaddr.h

@@ -0,0 +1,44 @@
+// Copyright 2021 The 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.
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_SOCKADDR_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_SOCKADDR_H
+
+#include <grpc/support/port_platform.h>
+
+#ifdef GRPC_USE_EVENT_ENGINE
+#include <grpc/event_engine/port.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+typedef struct sockaddr grpc_sockaddr;
+typedef struct sockaddr_in grpc_sockaddr_in;
+typedef struct sockaddr_in6 grpc_sockaddr_in6;
+typedef struct in_addr grpc_in_addr;
+typedef struct in6_addr grpc_in6_addr;
+
+#define GRPC_INET_ADDRSTRLEN INET_ADDRSTRLEN
+#define GRPC_INET6_ADDRSTRLEN INET6_ADDRSTRLEN
+
+#define GRPC_SOCK_STREAM SOCK_STREAM
+#define GRPC_SOCK_DGRAM SOCK_DGRAM
+
+#define GRPC_AF_UNSPEC AF_UNSPEC
+#define GRPC_AF_UNIX AF_UNIX
+#define GRPC_AF_INET AF_INET
+#define GRPC_AF_INET6 AF_INET6
+
+#define GRPC_AI_PASSIVE AI_PASSIVE
+
+#endif
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_SOCKADDR_H

data/src/core/lib/gpr/wrap_memcpy.cc

@@ -28,7 +28,8 @@
 
 extern "C" {
 #ifdef __linux__
-#if defined(__x86_64__) && !defined(GPR_MUSL_LIBC_COMPAT)
+#if defined(__x86_64__) && !defined(GPR_MUSL_LIBC_COMPAT) && \
+    !defined(__ANDROID__)
 __asm__(".symver memcpy,memcpy@GLIBC_2.2.5");
 void* __wrap_memcpy(void* destination, const void* source, size_t num) {
   return memcpy(destination, source, num);

data/src/core/lib/gprpp/ref_counted.h

@@ -215,31 +215,45 @@ class NonPolymorphicRefCount {
   ~NonPolymorphicRefCount() = default;
 };
 
+// Behavior of RefCounted<> upon ref count reaching 0.
+enum UnrefBehavior {
+  // Default behavior: Delete the object.
+  kUnrefDelete,
+  // Do not delete the object upon unref.  This is useful in cases where all
+  // existing objects must be tracked in a registry but the object's entry in
+  // the registry cannot be removed from the object's dtor due to
+  // synchronization issues.  In this case, the registry can be cleaned up
+  // later by identifying entries for which RefIfNonZero() returns null.
+  kUnrefNoDelete,
+  // Call the object's dtor but do not delete it.  This is useful for cases
+  // where the object is stored in memory allocated elsewhere (e.g., the call
+  // arena).
+  kUnrefCallDtor,
+};
+
 namespace internal {
-template <typename T, bool DoDelete>
+template <typename T, UnrefBehavior UnrefBehaviorArg>
 class Delete;
 template <typename T>
-class Delete<T, true> {
+class Delete<T, kUnrefDelete> {
  public:
   explicit Delete(T* t) { delete t; }
 };
 template <typename T>
-class Delete<T, false> {
+class Delete<T, kUnrefNoDelete> {
  public:
   explicit Delete(T* /*t*/) {}
 };
+template <typename T>
+class Delete<T, kUnrefCallDtor> {
+ public:
+  explicit Delete(T* t) { t->~T(); }
+};
 }  // namespace internal
 
 // A base class for reference-counted objects.
 // New objects should be created via new and start with a refcount of 1.
-// When the refcount reaches 0, the object will be deleted via delete.
-//
-// If DeleteUponUnref is false, deletion will not occur when the ref
-// count reaches 0.  This is useful in cases where all existing objects
-// must be tracked in a registry but the object's entry in the registry
-// cannot be removed from the object's dtor due to synchronization issues.
-// In this case, the registry can be cleaned up later by identifying
-// entries for which RefIfNonZero() returns null.
+// When the refcount reaches 0, executes the specified UnrefBehavior.
 //
 // This will commonly be used by CRTP (curiously-recurring template pattern)
 // e.g., class MyClass : public RefCounted<MyClass>
@@ -264,7 +278,7 @@ class Delete<T, false> {
 //    ch->Unref();
 //
 template <typename Child, typename Impl = PolymorphicRefCount,
-          bool DeleteUponUnref = true>
+          UnrefBehavior UnrefBehaviorArg = kUnrefDelete>
 class RefCounted : public Impl {
  public:
   // Note: Depending on the Impl used, this dtor can be implicitly virtual.
@@ -287,12 +301,12 @@ class RefCounted : public Impl {
   // friend of this class.
   void Unref() {
     if (GPR_UNLIKELY(refs_.Unref())) {
-      internal::Delete<Child, DeleteUponUnref>(static_cast<Child*>(this));
+      internal::Delete<Child, UnrefBehaviorArg>(static_cast<Child*>(this));
     }
   }
   void Unref(const DebugLocation& location, const char* reason) {
     if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      internal::Delete<Child, DeleteUponUnref>(static_cast<Child*>(this));
+      internal::Delete<Child, UnrefBehaviorArg>(static_cast<Child*>(this));
     }
   }
 

data/src/core/lib/gprpp/status_helper.cc

@@ -0,0 +1,407 @@
+//
+//
+// Copyright 2021 the 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 "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/gprpp/time_util.h"
+
+#include <grpc/support/log.h>
+
+#include "absl/strings/cord.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+#include "absl/time/clock.h"
+
+#include "google/protobuf/any.upb.h"
+#include "google/rpc/status.upb.h"
+#include "upb/upb.hpp"
+
+namespace grpc_core {
+
+namespace {
+
+#define TYPE_URL_PREFIX "type.googleapis.com/grpc.status."
+#define TYPE_INT_TAG "int."
+#define TYPE_STR_TAG "str."
+#define TYPE_TIME_TAG "time."
+#define TYPE_CHILDREN_TAG "children"
+#define TYPE_URL(name) (TYPE_URL_PREFIX name)
+const absl::string_view kTypeUrlPrefix = TYPE_URL_PREFIX;
+const absl::string_view kTypeIntTag = TYPE_INT_TAG;
+const absl::string_view kTypeStrTag = TYPE_STR_TAG;
+const absl::string_view kTypeTimeTag = TYPE_TIME_TAG;
+const absl::string_view kTypeChildrenTag = TYPE_CHILDREN_TAG;
+const absl::string_view kChildrenPropertyUrl = TYPE_URL(TYPE_CHILDREN_TAG);
+
+const char* GetStatusIntPropertyUrl(StatusIntProperty key) {
+  switch (key) {
+    case StatusIntProperty::kErrorNo:
+      return TYPE_URL(TYPE_INT_TAG "errno");
+    case StatusIntProperty::kFileLine:
+      return TYPE_URL(TYPE_INT_TAG "file_line");
+    case StatusIntProperty::kStreamId:
+      return TYPE_URL(TYPE_INT_TAG "stream_id");
+    case StatusIntProperty::kRpcStatus:
+      return TYPE_URL(TYPE_INT_TAG "grpc_status");
+    case StatusIntProperty::kOffset:
+      return TYPE_URL(TYPE_INT_TAG "offset");
+    case StatusIntProperty::kIndex:
+      return TYPE_URL(TYPE_INT_TAG "index");
+    case StatusIntProperty::kSize:
+      return TYPE_URL(TYPE_INT_TAG "size");
+    case StatusIntProperty::kHttp2Error:
+      return TYPE_URL(TYPE_INT_TAG "http2_error");
+    case StatusIntProperty::kTsiCode:
+      return TYPE_URL(TYPE_INT_TAG "tsi_code");
+    case StatusIntProperty::kWsaError:
+      return TYPE_URL(TYPE_INT_TAG "wsa_error");
+    case StatusIntProperty::kFd:
+      return TYPE_URL(TYPE_INT_TAG "fd");
+    case StatusIntProperty::kHttpStatus:
+      return TYPE_URL(TYPE_INT_TAG "http_status");
+    case StatusIntProperty::kOccurredDuringWrite:
+      return TYPE_URL(TYPE_INT_TAG "occurred_during_write");
+    case StatusIntProperty::ChannelConnectivityState:
+      return TYPE_URL(TYPE_INT_TAG "channel_connectivity_state");
+    case StatusIntProperty::kLbPolicyDrop:
+      return TYPE_URL(TYPE_INT_TAG "lb_policy_drop");
+  }
+  GPR_UNREACHABLE_CODE(return "unknown");
+}
+
+const char* GetStatusStrPropertyUrl(StatusStrProperty key) {
+  switch (key) {
+    case StatusStrProperty::kDescription:
+      return TYPE_URL(TYPE_STR_TAG "description");
+    case StatusStrProperty::kFile:
+      return TYPE_URL(TYPE_STR_TAG "file");
+    case StatusStrProperty::kOsError:
+      return TYPE_URL(TYPE_STR_TAG "os_error");
+    case StatusStrProperty::kSyscall:
+      return TYPE_URL(TYPE_STR_TAG "syscall");
+    case StatusStrProperty::kTargetAddress:
+      return TYPE_URL(TYPE_STR_TAG "target_address");
+    case StatusStrProperty::kGrpcMessage:
+      return TYPE_URL(TYPE_STR_TAG "grpc_message");
+    case StatusStrProperty::kRawBytes:
+      return TYPE_URL(TYPE_STR_TAG "raw_bytes");
+    case StatusStrProperty::kTsiError:
+      return TYPE_URL(TYPE_STR_TAG "tsi_error");
+    case StatusStrProperty::kFilename:
+      return TYPE_URL(TYPE_STR_TAG "filename");
+    case StatusStrProperty::kKey:
+      return TYPE_URL(TYPE_STR_TAG "key");
+    case StatusStrProperty::kValue:
+      return TYPE_URL(TYPE_STR_TAG "value");
+  }
+  GPR_UNREACHABLE_CODE(return "unknown");
+}
+
+const char* GetStatusTimePropertyUrl(StatusTimeProperty key) {
+  switch (key) {
+    case StatusTimeProperty::kCreated:
+      return TYPE_URL(TYPE_TIME_TAG "created_time");
+  }
+  GPR_UNREACHABLE_CODE(return "unknown");
+}
+
+void EncodeUInt32ToBytes(uint32_t v, char* buf) {
+  buf[0] = v & 0xFF;
+  buf[1] = (v >> 8) & 0xFF;
+  buf[2] = (v >> 16) & 0xFF;
+  buf[3] = (v >> 24) & 0xFF;
+}
+
+uint32_t DecodeUInt32FromBytes(const char* buf) {
+  return buf[0] | (uint32_t(buf[1]) << 8) | (uint32_t(buf[2]) << 16) |
+         (uint32_t(buf[3]) << 24);
+}
+
+std::vector<absl::Status> ParseChildren(absl::Cord children) {
+  std::vector<absl::Status> result;
+  upb::Arena arena;
+  // Cord is flattened to iterate the buffer easily at the cost of memory copy.
+  // TODO(veblush): Optimize this once CordReader is introduced.
+  absl::string_view buf = children.Flatten();
+  size_t cur = 0;
+  while (buf.size() - cur >= sizeof(uint32_t)) {
+    size_t msg_size = DecodeUInt32FromBytes(buf.data() + cur);
+    cur += sizeof(uint32_t);
+    GPR_ASSERT(buf.size() - cur >= msg_size);
+    google_rpc_Status* msg =
+        google_rpc_Status_parse(buf.data() + cur, msg_size, arena.ptr());
+    cur += msg_size;
+    result.push_back(internal::StatusFromProto(msg));
+  }
+  return result;
+}
+
+}  // namespace
+
+absl::Status StatusCreate(absl::StatusCode code, absl::string_view msg,
+                          const DebugLocation& location,
+                          std::initializer_list<absl::Status> children) {
+  absl::Status s(code, msg);
+  if (location.file() != nullptr) {
+    StatusSetStr(&s, StatusStrProperty::kFile, location.file());
+  }
+  if (location.line() != -1) {
+    StatusSetInt(&s, StatusIntProperty::kFileLine, location.line());
+  }
+  StatusSetTime(&s, StatusTimeProperty::kCreated, absl::Now());
+  for (const absl::Status& child : children) {
+    if (!child.ok()) {
+      StatusAddChild(&s, child);
+    }
+  }
+  return s;
+}
+
+void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value) {
+  status->SetPayload(GetStatusIntPropertyUrl(key),
+                     absl::Cord(std::to_string(value)));
+}
+
+absl::optional<intptr_t> StatusGetInt(const absl::Status& status,
+                                      StatusIntProperty key) {
+  absl::optional<absl::Cord> p =
+      status.GetPayload(GetStatusIntPropertyUrl(key));
+  if (p.has_value()) {
+    absl::optional<absl::string_view> sv = p->TryFlat();
+    intptr_t value;
+    if (sv.has_value()) {
+      if (absl::SimpleAtoi(*sv, &value)) {
+        return value;
+      }
+    } else {
+      if (absl::SimpleAtoi(std::string(*p), &value)) {
+        return value;
+      }
+    }
+  }
+  return {};
+}
+
+void StatusSetStr(absl::Status* status, StatusStrProperty key,
+                  absl::string_view value) {
+  status->SetPayload(GetStatusStrPropertyUrl(key), absl::Cord(value));
+}
+
+absl::optional<std::string> StatusGetStr(const absl::Status& status,
+                                         StatusStrProperty key) {
+  absl::optional<absl::Cord> p =
+      status.GetPayload(GetStatusStrPropertyUrl(key));
+  if (p.has_value()) {
+    return std::string(*p);
+  }
+  return {};
+}
+
+void StatusSetTime(absl::Status* status, StatusTimeProperty key,
+                   absl::Time time) {
+  status->SetPayload(GetStatusTimePropertyUrl(key),
+                     absl::Cord(absl::string_view(
+                         reinterpret_cast<const char*>(&time), sizeof(time))));
+}
+
+absl::optional<absl::Time> StatusGetTime(const absl::Status& status,
+                                         StatusTimeProperty key) {
+  absl::optional<absl::Cord> p =
+      status.GetPayload(GetStatusTimePropertyUrl(key));
+  if (p.has_value()) {
+    absl::optional<absl::string_view> sv = p->TryFlat();
+    if (sv.has_value()) {
+      return *reinterpret_cast<const absl::Time*>(sv->data());
+    } else {
+      std::string s = std::string(*p);
+      return *reinterpret_cast<const absl::Time*>(s.c_str());
+    }
+  }
+  return {};
+}
+
+void StatusAddChild(absl::Status* status, absl::Status child) {
+  upb::Arena arena;
+  // Serialize msg to buf
+  google_rpc_Status* msg = internal::StatusToProto(child, arena.ptr());
+  size_t buf_len = 0;
+  char* buf = google_rpc_Status_serialize(msg, arena.ptr(), &buf_len);
+  // Append (msg-length and msg) to children payload
+  absl::optional<absl::Cord> old_children =
+      status->GetPayload(kChildrenPropertyUrl);
+  absl::Cord children;
+  if (old_children.has_value()) {
+    children = *old_children;
+  }
+  char head_buf[sizeof(uint32_t)];
+  EncodeUInt32ToBytes(buf_len, head_buf);
+  children.Append(absl::string_view(head_buf, sizeof(uint32_t)));
+  children.Append(absl::string_view(buf, buf_len));
+  status->SetPayload(kChildrenPropertyUrl, std::move(children));
+}
+
+std::vector<absl::Status> StatusGetChildren(absl::Status status) {
+  absl::optional<absl::Cord> children = status.GetPayload(kChildrenPropertyUrl);
+  return children.has_value() ? ParseChildren(*children)
+                              : std::vector<absl::Status>();
+}
+
+std::string StatusToString(const absl::Status& status) {
+  if (status.ok()) {
+    return "OK";
+  }
+  std::string head;
+  absl::StrAppend(&head, absl::StatusCodeToString(status.code()));
+  if (!status.message().empty()) {
+    absl::StrAppend(&head, ":", status.message());
+  }
+  std::vector<std::string> kvs;
+  absl::optional<absl::Cord> children;
+  status.ForEachPayload([&](absl::string_view type_url,
+                            const absl::Cord& payload) {
+    if (absl::StartsWith(type_url, kTypeUrlPrefix)) {
+      type_url.remove_prefix(kTypeUrlPrefix.size());
+      if (type_url == kTypeChildrenTag) {
+        children = payload;
+        return;
+      }
+      absl::string_view payload_view;
+      std::string payload_storage;
+      if (payload.TryFlat().has_value()) {
+        payload_view = payload.TryFlat().value();
+      } else {
+        payload_storage = std::string(payload);
+        payload_view = payload_storage;
+      }
+      if (absl::StartsWith(type_url, kTypeIntTag)) {
+        type_url.remove_prefix(kTypeIntTag.size());
+        kvs.push_back(absl::StrCat(type_url, ":", payload_view));
+      } else if (absl::StartsWith(type_url, kTypeStrTag)) {
+        type_url.remove_prefix(kTypeStrTag.size());
+        kvs.push_back(absl::StrCat(type_url, ":\"",
+                                   absl::CHexEscape(payload_view), "\""));
+      } else if (absl::StartsWith(type_url, kTypeTimeTag)) {
+        type_url.remove_prefix(kTypeTimeTag.size());
+        absl::Time t =
+            *reinterpret_cast<const absl::Time*>(payload_view.data());
+        kvs.push_back(absl::StrCat(type_url, ":\"", absl::FormatTime(t), "\""));
+      } else {
+        kvs.push_back(absl::StrCat(type_url, ":\"",
+                                   absl::CHexEscape(payload_view), "\""));
+      }
+    } else {
+      absl::optional<absl::string_view> payload_view = payload.TryFlat();
+      std::string payload_str = absl::CHexEscape(
+          payload_view.has_value() ? *payload_view : std::string(payload));
+      kvs.push_back(absl::StrCat(type_url, ":\"", payload_str, "\""));
+    }
+  });
+  if (children.has_value()) {
+    std::vector<absl::Status> children_status = ParseChildren(*children);
+    std::vector<std::string> children_text;
+    children_text.reserve(children_status.size());
+    for (const absl::Status& child_status : children_status) {
+      children_text.push_back(StatusToString(child_status));
+    }
+    kvs.push_back(
+        absl::StrCat("children:[", absl::StrJoin(children_text, ", "), "]"));
+  }
+  return kvs.empty() ? head
+                     : absl::StrCat(head, " {", absl::StrJoin(kvs, ", "), "}");
+}
+
+namespace internal {
+
+google_rpc_Status* StatusToProto(absl::Status status, upb_arena* arena) {
+  google_rpc_Status* msg = google_rpc_Status_new(arena);
+  google_rpc_Status_set_code(msg, int32_t(status.code()));
+  google_rpc_Status_set_message(
+      msg, upb_strview_make(status.message().data(), status.message().size()));
+  status.ForEachPayload([&](absl::string_view type_url,
+                            const absl::Cord& payload) {
+    google_protobuf_Any* any = google_rpc_Status_add_details(msg, arena);
+    char* type_url_buf =
+        reinterpret_cast<char*>(upb_arena_malloc(arena, type_url.size()));
+    memcpy(type_url_buf, type_url.data(), type_url.size());
+    google_protobuf_Any_set_type_url(
+        any, upb_strview_make(type_url_buf, type_url.size()));
+    absl::optional<absl::string_view> v_view = payload.TryFlat();
+    if (v_view.has_value()) {
+      google_protobuf_Any_set_value(
+          any, upb_strview_make(v_view->data(), v_view->size()));
+    } else {
+      char* buf =
+          reinterpret_cast<char*>(upb_arena_malloc(arena, payload.size()));
+      char* cur = buf;
+      for (absl::string_view chunk : payload.Chunks()) {
+        memcpy(cur, chunk.data(), chunk.size());
+        cur += chunk.size();
+      }
+      google_protobuf_Any_set_value(any, upb_strview_make(buf, payload.size()));
+    }
+  });
+  return msg;
+}
+
+absl::Status StatusFromProto(google_rpc_Status* msg) {
+  int32_t code = google_rpc_Status_code(msg);
+  upb_strview message = google_rpc_Status_message(msg);
+  absl::Status status(static_cast<absl::StatusCode>(code),
+                      absl::string_view(message.data, message.size));
+  size_t detail_len;
+  const google_protobuf_Any* const* details =
+      google_rpc_Status_details(msg, &detail_len);
+  for (size_t i = 0; i < detail_len; i++) {
+    upb_strview type_url = google_protobuf_Any_type_url(details[i]);
+    upb_strview value = google_protobuf_Any_value(details[i]);
+    status.SetPayload(absl::string_view(type_url.data, type_url.size),
+                      absl::Cord(absl::string_view(value.data, value.size)));
+  }
+  return status;
+}
+
+uintptr_t StatusAllocPtr(absl::Status s) {
+  // This relies the fact that absl::Status has only one member, StatusRep*
+  // so the sizeof(absl::Status) has the same size of intptr_t and StatusRep*
+  // can be stolen using placement allocation.
+  static_assert(sizeof(intptr_t) == sizeof(absl::Status),
+                "absl::Status should be as big as intptr_t");
+  // This does two things;
+  // 1. Copies StatusRep* of absl::Status to ptr
+  // 2. Increases the counter of StatusRep if it's not inlined
+  uintptr_t ptr;
+  new (&ptr) absl::Status(s);
+  return ptr;
+}
+
+void StatusFreePtr(uintptr_t ptr) {
+  // Decreases the counter of StatusRep if it's not inlined.
+  reinterpret_cast<absl::Status*>(&ptr)->~Status();
+}
+
+absl::Status StatusGetFromPtr(uintptr_t ptr) {
+  // Constructs Status from ptr having the address of StatusRep.
+  return *reinterpret_cast<absl::Status*>(&ptr);
+}
+
+}  // namespace internal
+
+}  // namespace grpc_core