grpc 1.48.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/src/core/lib/iomgr/resolve_address_windows.h

@@ -32,15 +32,29 @@ class NativeDNSResolver : public DNSResolver {
   // Gets the singleton instance, creating it first if it doesn't exist
   static NativeDNSResolver* GetOrCreate();
 
-  TaskHandle ResolveName(
-      absl::string_view name, absl::string_view default_port,
-      grpc_pollset_set* /* interested_parties */,
+  TaskHandle LookupHostname(
       std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
-          on_done) override;
+          on_resolved,
+      absl::string_view name, absl::string_view default_port, Duration timeout,
+      grpc_pollset_set* interested_parties,
+      absl::string_view name_server) override;
 
-  absl::StatusOr<std::vector<grpc_resolved_address>> ResolveNameBlocking(
+  absl::StatusOr<std::vector<grpc_resolved_address>> LookupHostnameBlocking(
       absl::string_view name, absl::string_view default_port) override;
 
+  TaskHandle LookupSRV(
+      std::function<void(absl::StatusOr<std::vector<grpc_resolved_address>>)>
+          on_resolved,
+      absl::string_view name, Duration timeout,
+      grpc_pollset_set* interested_parties,
+      absl::string_view name_server) override;
+
+  TaskHandle LookupTXT(
+      std::function<void(absl::StatusOr<std::string>)> on_resolved,
+      absl::string_view name, Duration timeout,
+      grpc_pollset_set* interested_parties,
+      absl::string_view name_server) override;
+
   // NativeDNSResolver does not support cancellation.
   bool Cancel(TaskHandle handle) override;
 };

data/src/core/lib/iomgr/socket_windows.h

@@ -86,8 +86,6 @@ typedef struct grpc_winsocket {
      This prevents that. */
   int added_to_iocp;
 
-  grpc_closure shutdown_closure;
-
   /* A label for iomgr to track outstanding objects */
   grpc_iomgr_object iomgr_object;
 } grpc_winsocket;

data/src/core/lib/iomgr/tcp_posix.cc

@@ -234,7 +234,11 @@ class TcpZerocopySendCtx {
   // buffers that were sent with the corresponding call to sendmsg().
   void NoteSend(TcpZerocopySendRecord* record) {
     record->Ref();
-    AssociateSeqWithSendRecord(last_send_, record);
+    {
+      MutexLock guard(&lock_);
+      is_in_write_ = true;
+      AssociateSeqWithSendRecordLocked(last_send_, record);
+    }
     ++last_send_;
   }
 
@@ -255,8 +259,8 @@ class TcpZerocopySendCtx {
 
   // Simply associate this send record (and the underlying sent data buffers)
   // with the implicit sequence number for this zerocopy sendmsg().
-  void AssociateSeqWithSendRecord(uint32_t seq, TcpZerocopySendRecord* record) {
-    MutexLock guard(&lock_);
+  void AssociateSeqWithSendRecordLocked(uint32_t seq,
+                                        TcpZerocopySendRecord* record) {
     ctx_lookup_.emplace(seq, record);
   }
 
@@ -314,7 +318,107 @@ class TcpZerocopySendCtx {
   // zerocopy is not useful for small transfers.
   size_t threshold_bytes() const { return threshold_bytes_; }
 
+  // Expected to be called by handler reading messages from the err queue.
+  // It is used to indicate that some OMem meory is now available. It returns
+  // true to tell the caller to mark the file descriptor as immediately
+  // writable.
+  //
+  // If a write is currently in progress on the socket (ie. we have issued a
+  // sendmsg() and are about to check its return value) then we set omem state
+  // to CHECK to make the sending thread know that some tcp_omem was
+  // concurrently freed even if sendmsg() returns ENOBUFS. In this case, since
+  // there is already an active send thread, we do not need to mark the
+  // socket writeable, so we return false.
+  //
+  // If there was no write in progress on the socket, and the socket was not
+  // marked as FULL, then we need not mark the socket writeable now that some
+  // tcp_omem memory is freed since it was not considered as blocked on
+  // tcp_omem to begin with. So in this case, return false.
+  //
+  // But, if a write was not in progress and the omem state was FULL, then we
+  // need to mark the socket writeable since it is no longer blocked by
+  // tcp_omem. In this case, return true.
+  //
+  // Please refer to the STATE TRANSITION DIAGRAM below for more details.
+  //
+  bool UpdateZeroCopyOMemStateAfterFree() {
+    MutexLock guard(&lock_);
+    if (is_in_write_) {
+      zcopy_enobuf_state_ = OMemState::CHECK;
+      return false;
+    }
+    GPR_DEBUG_ASSERT(zcopy_enobuf_state_ != OMemState::CHECK);
+    if (zcopy_enobuf_state_ == OMemState::FULL) {
+      // A previous sendmsg attempt was blocked by ENOBUFS. Return true to
+      // mark the fd as writable so the next write attempt could be made.
+      zcopy_enobuf_state_ = OMemState::OPEN;
+      return true;
+    } else if (zcopy_enobuf_state_ == OMemState::OPEN) {
+      // No need to mark the fd as writable because the previous write
+      // attempt did not encounter ENOBUFS.
+      return false;
+    } else {
+      // This state should never be reached because it implies that the previous
+      // state was CHECK and is_in_write is false. This means that after the
+      // previous sendmsg returned and set is_in_write to false, it did
+      // not update the z-copy change from CHECK to OPEN.
+      GPR_ASSERT(false && "OMem state error!");
+    }
+  }
+
+  // Expected to be called by the thread calling sendmsg after the syscall
+  // invocation. is complete. If an ENOBUF is seen, it checks if the error
+  // handler (Tx0cp completions) has already run and free'ed up some OMem. It
+  // returns true indicating that the write can be attempted again immediately.
+  // If ENOBUFS was seen but no Tx0cp completions have been received between the
+  // sendmsg() and us taking this lock, then tcp_omem is still full from our
+  // point of view. Therefore, we do not signal that the socket is writeable
+  // with respect to the availability of tcp_omem. Therefore the function
+  // returns false. This indicates that another write should not be attempted
+  // immediately and the calling thread should wait until the socket is writable
+  // again. If ENOBUFS was not seen, then again return false because the next
+  // write should be attempted only when the socket is writable again.
+  //
+  // Please refer to the STATE TRANSITION DIAGRAM below for more details.
+  //
+  bool UpdateZeroCopyOMemStateAfterSend(bool seen_enobuf) {
+    MutexLock guard(&lock_);
+    is_in_write_ = false;
+    if (seen_enobuf) {
+      if (zcopy_enobuf_state_ == OMemState::CHECK) {
+        zcopy_enobuf_state_ = OMemState::OPEN;
+        return true;
+      } else {
+        zcopy_enobuf_state_ = OMemState::FULL;
+      }
+    } else if (zcopy_enobuf_state_ != OMemState::OPEN) {
+      zcopy_enobuf_state_ = OMemState::OPEN;
+    }
+    return false;
+  }
+
  private:
+  //                      STATE TRANSITION DIAGRAM
+  //
+  // sendmsg succeeds       Tx-zero copy succeeds and there is no active sendmsg
+  //      ----<<--+  +------<<-------------------------------------+
+  //      |       |  |                                             |
+  //      |       |  v       sendmsg returns ENOBUFS               |
+  //      +-----> OPEN  ------------->>-------------------------> FULL
+  //                ^                                              |
+  //                |                                              |
+  //                | sendmsg completes                            |
+  //                +----<<---------- CHECK <-------<<-------------+
+  //                                        Tx-zero copy succeeds and there is
+  //                                        an active sendmsg
+  //
+  enum class OMemState : int8_t {
+    OPEN,   // Everything is clear and omem is not full.
+    FULL,   // The last sendmsg() has returned with an errno of ENOBUFS.
+    CHECK,  // Error queue is read while is_in_write_ was true, so we should
+            // check this state after the sendmsg.
+  };
+
   TcpZerocopySendRecord* ReleaseSendRecordLocked(uint32_t seq) {
     auto iter = ctx_lookup_.find(seq);
     GPR_DEBUG_ASSERT(iter != ctx_lookup_.end());
@@ -351,6 +455,8 @@ class TcpZerocopySendCtx {
   size_t threshold_bytes_ = kDefaultSendBytesThreshold;
   std::unordered_map<uint32_t, TcpZerocopySendRecord*> ctx_lookup_;
   bool memory_limited_ = false;
+  bool is_in_write_ = false;
+  OMemState zcopy_enobuf_state_;
 };
 
 }  // namespace grpc_core
@@ -1126,6 +1232,9 @@ static void process_zerocopy(grpc_tcp* tcp, struct cmsghdr* cmsg) {
     GPR_DEBUG_ASSERT(record);
     UnrefMaybePutZerocopySendRecord(tcp, record, seq, "CALLBACK RCVD");
   }
+  if (tcp->tcp_zerocopy_send_ctx.UpdateZeroCopyOMemStateAfterFree()) {
+    grpc_fd_set_writable(tcp->em_fd);
+  }
 }
 
 // Whether the cmsg received from error queue is of the IPv4 or IPv6 levels.
@@ -1436,10 +1545,14 @@ static bool do_tcp_flush_zerocopy(grpc_tcp* tcp, TcpZerocopySendRecord* record,
       GRPC_STATS_INC_TCP_WRITE_IOV_SIZE(iov_size);
       sent_length = tcp_send(tcp->fd, &msg, &saved_errno, MSG_ZEROCOPY);
     }
+    if (tcp->tcp_zerocopy_send_ctx.UpdateZeroCopyOMemStateAfterSend(
+            saved_errno == ENOBUFS)) {
+      grpc_fd_set_writable(tcp->em_fd);
+    }
     if (sent_length < 0) {
       // If this particular send failed, drop ref taken earlier in this method.
       tcp->tcp_zerocopy_send_ctx.UndoSend();
-      if (saved_errno == EAGAIN) {
+      if (saved_errno == EAGAIN || saved_errno == ENOBUFS) {
         record->UnwindIfThrottled(unwind_slice_idx, unwind_byte_idx);
         return false;
       } else if (saved_errno == EPIPE) {
@@ -1547,7 +1660,7 @@ static bool tcp_flush(grpc_tcp* tcp, grpc_error_handle* error) {
     }
 
     if (sent_length < 0) {
-      if (saved_errno == EAGAIN) {
+      if (saved_errno == EAGAIN || saved_errno == ENOBUFS) {
         tcp->outgoing_byte_idx = unwind_byte_idx;
         // unref all and forget about all slices that have been written to this
         // point
@@ -1609,7 +1722,6 @@ static void tcp_handle_write(void* arg /* grpc_tcp */,
     TCP_UNREF(tcp, "write");
     return;
   }
-
   bool flush_result =
       tcp->current_zerocopy_send != nullptr
           ? tcp_flush_zerocopy(tcp, tcp->current_zerocopy_send, &error)

data/src/core/lib/iomgr/timer_generic.cc

@@ -33,10 +33,11 @@
 #include "src/core/lib/gpr/spinlock.h"
 #include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/time_averaged_stats.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/port.h"
-#include "src/core/lib/iomgr/time_averaged_stats.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/timer_heap.h"
 
@@ -60,7 +61,7 @@ grpc_core::TraceFlag grpc_timer_check_trace(false, "timer_check");
  */
 struct timer_shard {
   gpr_mu mu;
-  grpc_time_averaged_stats stats;
+  grpc_core::ManualConstructor<grpc_core::TimeAveragedStats> stats;
   /* All and only timers with deadlines < this will be in the heap. */
   grpc_core::Timestamp queue_deadline_cap;
   /* The deadline of the next timer due in this shard. */
@@ -259,8 +260,7 @@ static void timer_list_init() {
   for (i = 0; i < g_num_shards; i++) {
     timer_shard* shard = &g_shards[i];
     gpr_mu_init(&shard->mu);
-    grpc_time_averaged_stats_init(&shard->stats, 1.0 / ADD_DEADLINE_SCALE, 0.1,
-                                  0.5);
+    shard->stats.Init(1.0 / ADD_DEADLINE_SCALE, 0.1, 0.5);
     shard->queue_deadline_cap = g_shared_mutables.min_timer;
     shard->shard_queue_index = i;
     grpc_timer_heap_init(&shard->heap);
@@ -367,8 +367,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
     return;
   }
 
-  grpc_time_averaged_stats_add_sample(&shard->stats,
-                                      (deadline - now).millis() / 1000.0);
+  shard->stats->AddSample((deadline - now).millis() / 1000.0);
 
   ADD_TO_HASH_TABLE(timer);
 
@@ -473,8 +472,7 @@ static void timer_cancel(grpc_timer* timer) {
 static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
   /* Compute the new queue window width and bound by the limits: */
   double computed_deadline_delta =
-      grpc_time_averaged_stats_update_average(&shard->stats) *
-      ADD_DEADLINE_SCALE;
+      shard->stats->UpdateAverage() * ADD_DEADLINE_SCALE;
   double deadline_delta =
       grpc_core::Clamp(computed_deadline_delta, MIN_QUEUE_WINDOW_DURATION,
                        MAX_QUEUE_WINDOW_DURATION);

data/src/core/lib/json/json.h

@@ -1,20 +1,18 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+// Copyright 2015 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_JSON_JSON_H
 #define GRPC_CORE_LIB_JSON_JSON_H
@@ -26,10 +24,9 @@
 #include <utility>
 #include <vector>
 
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
-#include "src/core/lib/iomgr/error.h"
-
 namespace grpc_core {
 
 // A JSON value, which can be any one of object, array, string,
@@ -54,8 +51,8 @@ class Json {
   using Object = std::map<std::string, Json>;
   using Array = std::vector<Json>;
 
-  // Parses JSON string from json_str.  On error, sets *error.
-  static Json Parse(absl::string_view json_str, grpc_error_handle* error);
+  // Parses JSON string from json_str.
+  static absl::StatusOr<Json> Parse(absl::string_view json_str);
 
   Json() = default;
 
@@ -246,4 +243,4 @@ class Json {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_JSON_JSON_H */
+#endif  // GRPC_CORE_LIB_JSON_JSON_H

data/src/core/lib/json/json_args.h

@@ -0,0 +1,34 @@
+// Copyright 2020 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_JSON_JSON_ARGS_H
+#define GRPC_CORE_LIB_JSON_JSON_ARGS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+class JsonArgs {
+ public:
+  JsonArgs() = default;
+  virtual ~JsonArgs() = default;
+
+  virtual bool IsEnabled(absl::string_view /*key*/) const { return true; }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_JSON_JSON_ARGS_H

data/src/core/lib/json/json_object_loader.cc

@@ -0,0 +1,233 @@
+// Copyright 2020 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/json/json_object_loader.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/strip.h"
+
+namespace grpc_core {
+
+void ErrorList::PushField(absl::string_view ext) {
+  // Skip leading '.' for top-level field names.
+  if (fields_.empty()) absl::ConsumePrefix(&ext, ".");
+  fields_.emplace_back(std::string(ext));
+}
+
+void ErrorList::PopField() { fields_.pop_back(); }
+
+void ErrorList::AddError(absl::string_view error) {
+  field_errors_[absl::StrJoin(fields_, "")].emplace_back(error);
+}
+
+bool ErrorList::FieldHasErrors() const {
+  return field_errors_.find(absl::StrJoin(fields_, "")) != field_errors_.end();
+}
+
+absl::Status ErrorList::status() const {
+  if (field_errors_.empty()) return absl::OkStatus();
+  std::vector<std::string> errors;
+  for (const auto& p : field_errors_) {
+    if (p.second.size() > 1) {
+      errors.emplace_back(absl::StrCat("field:", p.first, " errors:[",
+                                       absl::StrJoin(p.second, "; "), "]"));
+    } else {
+      errors.emplace_back(
+          absl::StrCat("field:", p.first, " error:", p.second[0]));
+    }
+  }
+  return absl::InvalidArgumentError(absl::StrCat(
+      "errors validating JSON: [", absl::StrJoin(errors, "; "), "]"));
+}
+
+namespace json_detail {
+
+void LoadScalar::LoadInto(const Json& json, const JsonArgs& /*args*/, void* dst,
+                          ErrorList* errors) const {
+  // We accept either STRING or NUMBER for numeric values, as per
+  // https://developers.google.com/protocol-buffers/docs/proto3#json.
+  if (json.type() != Json::Type::STRING &&
+      (!IsNumber() || json.type() != Json::Type::NUMBER)) {
+    errors->AddError(
+        absl::StrCat("is not a ", IsNumber() ? "number" : "string"));
+    return;
+  }
+  return LoadInto(json.string_value(), dst, errors);
+}
+
+bool LoadString::IsNumber() const { return false; }
+
+void LoadString::LoadInto(const std::string& value, void* dst,
+                          ErrorList*) const {
+  *static_cast<std::string*>(dst) = value;
+}
+
+bool LoadDuration::IsNumber() const { return false; }
+
+void LoadDuration::LoadInto(const std::string& value, void* dst,
+                            ErrorList* errors) const {
+  absl::string_view buf(value);
+  if (!absl::ConsumeSuffix(&buf, "s")) {
+    errors->AddError("Not a duration (no s suffix)");
+    return;
+  }
+  buf = absl::StripAsciiWhitespace(buf);
+  auto decimal_point = buf.find('.');
+  int nanos = 0;
+  if (decimal_point != absl::string_view::npos) {
+    absl::string_view after_decimal = buf.substr(decimal_point + 1);
+    buf = buf.substr(0, decimal_point);
+    if (!absl::SimpleAtoi(after_decimal, &nanos)) {
+      errors->AddError("Not a duration (not a number of nanoseconds)");
+      return;
+    }
+    if (after_decimal.length() > 9) {
+      // We don't accept greater precision than nanos.
+      errors->AddError("Not a duration (too many digits after decimal)");
+      return;
+    }
+    for (size_t i = 0; i < (9 - after_decimal.length()); ++i) {
+      nanos *= 10;
+    }
+  }
+  int seconds;
+  if (!absl::SimpleAtoi(buf, &seconds)) {
+    errors->AddError("Not a duration (not a number of seconds)");
+    return;
+  }
+  *static_cast<Duration*>(dst) =
+      Duration::FromSecondsAndNanoseconds(seconds, nanos);
+}
+
+bool LoadNumber::IsNumber() const { return true; }
+
+void LoadBool::LoadInto(const Json& json, const JsonArgs&, void* dst,
+                        ErrorList* errors) const {
+  if (json.type() == Json::Type::JSON_TRUE) {
+    *static_cast<bool*>(dst) = true;
+  } else if (json.type() == Json::Type::JSON_FALSE) {
+    *static_cast<bool*>(dst) = false;
+  } else {
+    errors->AddError("is not a boolean");
+  }
+}
+
+void LoadUnprocessedJsonObject::LoadInto(const Json& json, const JsonArgs&,
+                                         void* dst, ErrorList* errors) const {
+  if (json.type() != Json::Type::OBJECT) {
+    errors->AddError("is not an object");
+    return;
+  }
+  *static_cast<Json::Object*>(dst) = json.object_value();
+}
+
+void LoadVector::LoadInto(const Json& json, const JsonArgs& args, void* dst,
+                          ErrorList* errors) const {
+  if (json.type() != Json::Type::ARRAY) {
+    errors->AddError("is not an array");
+    return;
+  }
+  const auto& array = json.array_value();
+  const LoaderInterface* element_loader = ElementLoader();
+  for (size_t i = 0; i < array.size(); ++i) {
+    ScopedField field(errors, absl::StrCat("[", i, "]"));
+    void* element = EmplaceBack(dst);
+    element_loader->LoadInto(array[i], args, element, errors);
+  }
+}
+
+void AutoLoader<std::vector<bool>>::LoadInto(const Json& json,
+                                             const JsonArgs& args, void* dst,
+                                             ErrorList* errors) const {
+  if (json.type() != Json::Type::ARRAY) {
+    errors->AddError("is not an array");
+    return;
+  }
+  const auto& array = json.array_value();
+  const LoaderInterface* element_loader = LoaderForType<bool>();
+  std::vector<bool>* vec = static_cast<std::vector<bool>*>(dst);
+  for (size_t i = 0; i < array.size(); ++i) {
+    ScopedField field(errors, absl::StrCat("[", i, "]"));
+    bool elem = false;
+    element_loader->LoadInto(array[i], args, &elem, errors);
+    vec->push_back(elem);
+  }
+}
+
+void LoadMap::LoadInto(const Json& json, const JsonArgs& args, void* dst,
+                       ErrorList* errors) const {
+  if (json.type() != Json::Type::OBJECT) {
+    errors->AddError("is not an object");
+    return;
+  }
+  const LoaderInterface* element_loader = ElementLoader();
+  for (const auto& pair : json.object_value()) {
+    ScopedField field(errors, absl::StrCat("[\"", pair.first, "\"]"));
+    void* element = Insert(pair.first, dst);
+    element_loader->LoadInto(pair.second, args, element, errors);
+  }
+}
+
+void LoadOptional::LoadInto(const Json& json, const JsonArgs& args, void* dst,
+                            ErrorList* errors) const {
+  if (json.type() == Json::Type::JSON_NULL) return;
+  void* element = Emplace(dst);
+  ElementLoader()->LoadInto(json, args, element, errors);
+}
+
+bool LoadObject(const Json& json, const JsonArgs& args, const Element* elements,
+                size_t num_elements, void* dst, ErrorList* errors) {
+  if (json.type() != Json::Type::OBJECT) {
+    errors->AddError("is not an object");
+    return false;
+  }
+  for (size_t i = 0; i < num_elements; ++i) {
+    const Element& element = elements[i];
+    if (element.enable_key != nullptr && !args.IsEnabled(element.enable_key)) {
+      continue;
+    }
+    ScopedField field(errors, absl::StrCat(".", element.name));
+    const auto& it = json.object_value().find(element.name);
+    if (it == json.object_value().end()) {
+      if (element.optional) continue;
+      errors->AddError("field not present");
+      continue;
+    }
+    char* field_dst = static_cast<char*>(dst) + element.member_offset;
+    element.loader->LoadInto(it->second, args, field_dst, errors);
+  }
+  return true;
+}
+
+const Json* GetJsonObjectField(const Json::Object& json,
+                               absl::string_view field, ErrorList* errors,
+                               bool required) {
+  auto it = json.find(std::string(field));
+  if (it == json.end()) {
+    if (required) errors->AddError("field not present");
+    return nullptr;
+  }
+  return &it->second;
+}
+
+}  // namespace json_detail
+}  // namespace grpc_core