grpc 1.52.0.pre2 → 1.53.0.pre2

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

@@ -16,19 +16,21 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H
 
 #include <grpc/support/port_platform.h>
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
@@ -57,7 +59,6 @@
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice_buffer.h"
@@ -147,8 +148,8 @@ struct grpc_chttp2_repeated_ping_policy {
 struct grpc_chttp2_repeated_ping_state {
   grpc_core::Timestamp last_ping_sent_time;
   int pings_before_data_required;
-  grpc_timer delayed_ping_timer;
-  bool is_delayed_ping_timer_set;
+  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+      delayed_ping_timer_handle;
 };
 struct grpc_chttp2_server_ping_recv_state {
   grpc_core::Timestamp last_ping_recv_time;
@@ -389,12 +390,16 @@ struct grpc_chttp2_transport
   uint32_t incoming_frame_size = 0;
   uint32_t incoming_stream_id = 0;
 
-  // active parser
-  void* parser_data = nullptr;
   grpc_chttp2_stream* incoming_stream = nullptr;
-  grpc_error_handle (*parser)(void* parser_user_data, grpc_chttp2_transport* t,
-                              grpc_chttp2_stream* s, const grpc_slice& slice,
-                              int is_last);
+  // active parser
+  struct Parser {
+    const char* name;
+    grpc_error_handle (*parser)(void* parser_user_data,
+                                grpc_chttp2_transport* t, grpc_chttp2_stream* s,
+                                const grpc_slice& slice, int is_last);
+    void* user_data = nullptr;
+  };
+  Parser parser;
 
   grpc_chttp2_write_cb* write_cb_pool = nullptr;
 
@@ -406,7 +411,6 @@ struct grpc_chttp2_transport
   grpc_closure finish_bdp_ping_locked;
 
   // if non-NULL, close the transport with this error when writes are finished
-  //
   grpc_error_handle close_transport_on_writes_finished;
 
   // a list of closures to run after writes are finished
@@ -422,25 +426,27 @@ struct grpc_chttp2_transport
   /// destructive cleanup closure
   grpc_closure destructive_reclaimer_locked;
 
-  // next bdp ping timer
-  bool have_next_bdp_ping_timer = false;
   /// If start_bdp_ping_locked has been called
   bool bdp_ping_started = false;
-  grpc_timer next_bdp_ping_timer;
+  // next bdp ping timer handle
+  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+      next_bdp_ping_timer_handle;
 
   // keep-alive ping support
   /// Closure to initialize a keepalive ping
   grpc_closure init_keepalive_ping_locked;
   /// Closure to run when the keepalive ping is sent
   grpc_closure start_keepalive_ping_locked;
-  /// Cousure to run when the keepalive ping ack is received
+  /// Closure to run when the keepalive ping ack is received
   grpc_closure finish_keepalive_ping_locked;
-  /// Closrue to run when the keepalive ping timeouts
+  /// Closure to run when the keepalive ping timeouts
   grpc_closure keepalive_watchdog_fired_locked;
   /// timer to initiate ping events
-  grpc_timer keepalive_ping_timer;
+  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+      keepalive_ping_timer_handle;
   /// watchdog to kill the transport when waiting for the keepalive ping
-  grpc_timer keepalive_watchdog_timer;
+  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+      keepalive_watchdog_timer_handle;
   /// time duration in between pings
   grpc_core::Duration keepalive_time;
   /// grace period for a ping to complete before watchdog kicks in
@@ -463,8 +469,9 @@ struct grpc_chttp2_transport
   bool reading_paused_on_pending_induced_frames = false;
   /// Based on channel args, preferred_rx_crypto_frame_sizes are advertised to
   /// the peer
-  ///
   bool enable_preferred_rx_crypto_frame_advertisement = false;
+
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine;
 };
 
 typedef enum {
@@ -563,8 +570,6 @@ struct grpc_chttp2_stream {
 
   grpc_core::Timestamp deadline = grpc_core::Timestamp::InfFuture();
 
-  /// saw some stream level error
-  grpc_error_handle forced_close_error;
   /// how many header frames have we received?
   uint8_t header_frames_received = 0;
   /// number of bytes received - reset at end of parse thread execution
@@ -801,10 +806,10 @@ void grpc_chttp2_fail_pending_writes(grpc_chttp2_transport* t,
 void grpc_chttp2_config_default_keepalive_args(grpc_channel_args* args,
                                                bool is_client);
 
-void grpc_chttp2_retry_initiate_ping(void* tp, grpc_error_handle error);
+void grpc_chttp2_retry_initiate_ping(grpc_chttp2_transport* t);
 
 void schedule_bdp_ping_locked(grpc_chttp2_transport* t);
 
 uint32_t grpc_chttp2_min_read_progress_size(grpc_chttp2_transport* t);
 
-#endif  // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_INTERNAL_H

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

@@ -18,15 +18,18 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
+#include <inttypes.h>
 #include <string.h>
 
+#include <initializer_list>
 #include <string>
+#include <utility>
 
 #include "absl/base/attributes.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
@@ -126,6 +129,65 @@ uint32_t grpc_chttp2_min_read_progress_size(grpc_chttp2_transport* t) {
   GPR_UNREACHABLE_CODE(return 1);
 }
 
+namespace {
+struct KnownFlag {
+  uint8_t flag;
+  absl::string_view name;
+};
+
+std::string MakeFrameTypeString(absl::string_view frame_type, uint8_t flags,
+                                std::initializer_list<KnownFlag> known_flags) {
+  std::string result(frame_type);
+  for (const KnownFlag& known_flag : known_flags) {
+    if (flags & known_flag.flag) {
+      absl::StrAppend(&result, ":", known_flag.name);
+      flags &= ~known_flag.flag;
+    }
+  }
+  if (flags != 0) {
+    absl::StrAppend(&result, ":UNKNOWN_FLAGS=0x",
+                    absl::Hex(flags, absl::kZeroPad2));
+  }
+  return result;
+}
+
+std::string FrameTypeString(uint8_t frame_type, uint8_t flags) {
+  switch (frame_type) {
+    case GRPC_CHTTP2_FRAME_DATA:
+      return MakeFrameTypeString(
+          "DATA", flags, {{GRPC_CHTTP2_DATA_FLAG_END_STREAM, "END_STREAM"}});
+    case GRPC_CHTTP2_FRAME_HEADER:
+      return MakeFrameTypeString(
+          "HEADERS", flags,
+          {{GRPC_CHTTP2_DATA_FLAG_END_STREAM, "END_STREAM"},
+           {GRPC_CHTTP2_DATA_FLAG_END_HEADERS, "END_HEADERS"},
+           {GRPC_CHTTP2_FLAG_HAS_PRIORITY, "PRIORITY"}});
+    case GRPC_CHTTP2_FRAME_CONTINUATION:
+      return MakeFrameTypeString(
+          "HEADERS", flags,
+          {{GRPC_CHTTP2_DATA_FLAG_END_STREAM, "END_STREAM"},
+           {GRPC_CHTTP2_DATA_FLAG_END_HEADERS, "END_HEADERS"},
+           {GRPC_CHTTP2_FLAG_HAS_PRIORITY, "PRIORITY"}});
+    case GRPC_CHTTP2_FRAME_RST_STREAM:
+      return MakeFrameTypeString("RST_STREAM", flags, {});
+    case GRPC_CHTTP2_FRAME_SETTINGS:
+      return MakeFrameTypeString("SETTINGS", flags,
+                                 {{GRPC_CHTTP2_FLAG_ACK, "ACK"}});
+    case GRPC_CHTTP2_FRAME_PING:
+      return MakeFrameTypeString("PING", flags,
+                                 {{GRPC_CHTTP2_FLAG_ACK, "ACK"}});
+    case GRPC_CHTTP2_FRAME_GOAWAY:
+      return MakeFrameTypeString("GOAWAY", flags, {});
+    case GRPC_CHTTP2_FRAME_WINDOW_UPDATE:
+      return MakeFrameTypeString("WINDOW_UPDATE", flags, {});
+    default:
+      return MakeFrameTypeString(
+          absl::StrCat("UNKNOWN_FRAME_TYPE_", static_cast<int>(frame_type)),
+          flags, {});
+  }
+}
+}  // namespace
+
 grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
                                            const grpc_slice& slice) {
   const uint8_t* beg = GRPC_SLICE_START_PTR(slice);
@@ -249,6 +311,12 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
     case GRPC_DTS_FH_8:
       GPR_DEBUG_ASSERT(cur < end);
       t->incoming_stream_id |= (static_cast<uint32_t>(*cur));
+      if (grpc_http_trace.enabled()) {
+        gpr_log(GPR_INFO, "INCOMING[%p]: %s len:%d id:0x%08x", t,
+                FrameTypeString(t->incoming_frame_type, t->incoming_frame_flags)
+                    .c_str(),
+                t->incoming_frame_size, t->incoming_stream_id);
+      }
       t->deframe_state = GRPC_DTS_FRAME;
       err = init_frame_parser(t);
       if (!err.ok()) {
@@ -403,8 +471,8 @@ static HPackParser::LogInfo hpack_parser_log_info(
 static grpc_error_handle init_header_skip_frame_parser(
     grpc_chttp2_transport* t, HPackParser::Priority priority_type) {
   bool is_eoh = t->expect_continuation_stream_id != 0;
-  t->parser = grpc_chttp2_header_parser_parse;
-  t->parser_data = &t->hpack_parser;
+  t->parser = grpc_chttp2_transport::Parser{
+      "header", grpc_chttp2_header_parser_parse, &t->hpack_parser};
   t->hpack_parser.BeginFrame(
       nullptr,
       t->settings[GRPC_ACKED_SETTINGS]
@@ -416,15 +484,17 @@ static grpc_error_handle init_header_skip_frame_parser(
 
 static grpc_error_handle init_non_header_skip_frame_parser(
     grpc_chttp2_transport* t) {
-  t->parser = skip_parser;
+  t->parser =
+      grpc_chttp2_transport::Parser{"skip_parser", skip_parser, nullptr};
   return absl::OkStatus();
 }
 
 void grpc_chttp2_parsing_become_skip_parser(grpc_chttp2_transport* t) {
-  if (t->parser == grpc_chttp2_header_parser_parse) {
+  if (t->parser.parser == grpc_chttp2_header_parser_parse) {
     t->hpack_parser.StopBufferingFrame();
   } else {
-    t->parser = skip_parser;
+    t->parser =
+        grpc_chttp2_transport::Parser{"skip_parser", skip_parser, nullptr};
   }
 }
 
@@ -471,9 +541,8 @@ static grpc_error_handle init_data_frame_parser(grpc_chttp2_transport* t) {
 error_handler:
   if (status.ok()) {
     t->incoming_stream = s;
-    // t->parser = grpc_chttp2_data_parser_parse;
-    t->parser = grpc_chttp2_data_parser_parse;
-    t->parser_data = nullptr;
+    t->parser = grpc_chttp2_transport::Parser{
+        "data", grpc_chttp2_data_parser_parse, nullptr};
     t->ping_state.last_ping_sent_time = grpc_core::Timestamp::InfPast();
     return absl::OkStatus();
   } else if (s != nullptr) {
@@ -583,8 +652,8 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     t->incoming_stream = nullptr;
     return init_header_skip_frame_parser(t, priority_type);
   }
-  t->parser = grpc_chttp2_header_parser_parse;
-  t->parser_data = &t->hpack_parser;
+  t->parser = grpc_chttp2_transport::Parser{
+      "header", grpc_chttp2_header_parser_parse, &t->hpack_parser};
   if (t->header_eof) {
     s->eos_received = true;
   }
@@ -639,12 +708,17 @@ static grpc_error_handle init_window_update_frame_parser(
     grpc_chttp2_stream* s = t->incoming_stream =
         grpc_chttp2_parsing_lookup_stream(t, t->incoming_stream_id);
     if (s == nullptr) {
+      if (grpc_http_trace.enabled()) {
+        gpr_log(GPR_ERROR, "Stream %d not found, ignoring WINDOW_UPDATE",
+                t->incoming_stream_id);
+      }
       return init_non_header_skip_frame_parser(t);
     }
     s->stats.incoming.framing_bytes += 9;
   }
-  t->parser = grpc_chttp2_window_update_parser_parse;
-  t->parser_data = &t->simple.window_update;
+  t->parser = grpc_chttp2_transport::Parser{
+      "window_update", grpc_chttp2_window_update_parser_parse,
+      &t->simple.window_update};
   return absl::OkStatus();
 }
 
@@ -652,8 +726,8 @@ static grpc_error_handle init_ping_parser(grpc_chttp2_transport* t) {
   grpc_error_handle err = grpc_chttp2_ping_parser_begin_frame(
       &t->simple.ping, t->incoming_frame_size, t->incoming_frame_flags);
   if (!err.ok()) return err;
-  t->parser = grpc_chttp2_ping_parser_parse;
-  t->parser_data = &t->simple.ping;
+  t->parser = grpc_chttp2_transport::Parser{
+      "ping", grpc_chttp2_ping_parser_parse, &t->simple.ping};
   return absl::OkStatus();
 }
 
@@ -667,8 +741,8 @@ static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t) {
     return init_non_header_skip_frame_parser(t);
   }
   s->stats.incoming.framing_bytes += 9;
-  t->parser = grpc_chttp2_rst_stream_parser_parse;
-  t->parser_data = &t->simple.rst_stream;
+  t->parser = grpc_chttp2_transport::Parser{
+      "rst_stream", grpc_chttp2_rst_stream_parser_parse, &t->simple.rst_stream};
   return absl::OkStatus();
 }
 
@@ -676,8 +750,8 @@ static grpc_error_handle init_goaway_parser(grpc_chttp2_transport* t) {
   grpc_error_handle err = grpc_chttp2_goaway_parser_begin_frame(
       &t->goaway_parser, t->incoming_frame_size, t->incoming_frame_flags);
   if (!err.ok()) return err;
-  t->parser = grpc_chttp2_goaway_parser_parse;
-  t->parser_data = &t->goaway_parser;
+  t->parser = grpc_chttp2_transport::Parser{
+      "goaway", grpc_chttp2_goaway_parser_parse, &t->goaway_parser};
   return absl::OkStatus();
 }
 
@@ -705,8 +779,8 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
         t, nullptr);
     t->sent_local_settings = false;
   }
-  t->parser = grpc_chttp2_settings_parser_parse;
-  t->parser_data = &t->simple.settings;
+  t->parser = grpc_chttp2_transport::Parser{
+      "settings", grpc_chttp2_settings_parser_parse, &t->simple.settings};
   return absl::OkStatus();
 }
 
@@ -714,21 +788,27 @@ static grpc_error_handle parse_frame_slice(grpc_chttp2_transport* t,
                                            const grpc_slice& slice,
                                            int is_last) {
   grpc_chttp2_stream* s = t->incoming_stream;
-  grpc_error_handle err = t->parser(t->parser_data, t, s, slice, is_last);
+  if (grpc_http_trace.enabled()) {
+    gpr_log(GPR_DEBUG,
+            "INCOMING[%p;%p]: Parse %" PRIdPTR "b %sframe fragment with %s", t,
+            s, GRPC_SLICE_LENGTH(slice), is_last ? "last " : "",
+            t->parser.name);
+  }
+  grpc_error_handle err =
+      t->parser.parser(t->parser.user_data, t, s, slice, is_last);
   intptr_t unused;
   if (GPR_LIKELY(err.ok())) {
     return err;
-  } else if (grpc_error_get_int(err, grpc_core::StatusIntProperty::kStreamId,
-                                &unused)) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace)) {
-      gpr_log(GPR_ERROR, "%s", grpc_core::StatusToString(err).c_str());
-    }
+  }
+  if (grpc_http_trace.enabled()) {
+    gpr_log(GPR_ERROR, "INCOMING[%p;%p]: Parse failed with %s", t, s,
+            err.ToString().c_str());
+  }
+  if (grpc_error_get_int(err, grpc_core::StatusIntProperty::kStreamId,
+                         &unused)) {
     grpc_chttp2_parsing_become_skip_parser(t);
     if (s) {
-      s->forced_close_error = err;
-      grpc_chttp2_add_rst_stream_to_next_write(t, t->incoming_stream_id,
-                                               GRPC_HTTP2_PROTOCOL_ERROR,
-                                               &s->stats.outgoing);
+      grpc_chttp2_cancel_stream(t, s, std::exchange(err, absl::OkStatus()));
     }
   }
   return err;

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

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_MAP_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_MAP_H
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_MAP_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_MAP_H
 
 #include <grpc/support/port_platform.h>
 
@@ -65,4 +65,4 @@ void grpc_chttp2_stream_map_for_each(grpc_chttp2_stream_map* map,
                                                void* value),
                                      void* user_data);
 
-#endif  // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_MAP_H
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_STREAM_MAP_H

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

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H
-#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H
 
 #include <grpc/support/port_platform.h>
 
@@ -73,4 +73,4 @@ class VarintWriter {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_VARINT_H

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

@@ -22,11 +22,13 @@
 #include <stddef.h>
 
 #include <algorithm>
+#include <memory>
 #include <string>
 
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
@@ -60,7 +62,6 @@
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/bdp_estimator.h"
 #include "src/core/lib/transport/http2_errors.h"
@@ -152,14 +153,14 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
           next_allowed_ping.milliseconds_after_process_epoch(),
           now.milliseconds_after_process_epoch());
     }
-    if (!t->ping_state.is_delayed_ping_timer_set) {
-      t->ping_state.is_delayed_ping_timer_set = true;
+    if (!t->ping_state.delayed_ping_timer_handle.has_value()) {
       GRPC_CHTTP2_REF_TRANSPORT(t, "retry_initiate_ping_locked");
-      GRPC_CLOSURE_INIT(&t->retry_initiate_ping_locked,
-                        grpc_chttp2_retry_initiate_ping, t,
-                        grpc_schedule_on_exec_ctx);
-      grpc_timer_init(&t->ping_state.delayed_ping_timer, next_allowed_ping,
-                      &t->retry_initiate_ping_locked);
+      t->ping_state.delayed_ping_timer_handle =
+          t->event_engine->RunAfter(next_allowed_ping - now, [t] {
+            grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+            grpc_core::ExecCtx exec_ctx;
+            grpc_chttp2_retry_initiate_ping(t);
+          });
     }
     return;
   }

data/src/core/ext/transport/inproc/inproc_transport.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H
-#define GRPC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H
 
 #include <grpc/support/port_platform.h>
 
@@ -31,4 +31,4 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
 
 extern grpc_core::TraceFlag grpc_inproc_trace;
 
-#endif  // GRPC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_INPROC_INPROC_TRANSPORT_H

data/src/core/ext/upb-generated/envoy/admin/v3/clusters.upb.c

@@ -41,7 +41,7 @@ static const upb_MiniTable_Sub envoy_admin_v3_ClusterStatus_submsgs[4] = {
   {.submsg = &envoy_config_cluster_v3_CircuitBreakers_msginit},
 };
 
-static const upb_MiniTable_Field envoy_admin_v3_ClusterStatus__fields[7] = {
+static const upb_MiniTable_Field envoy_admin_v3_ClusterStatus__fields[8] = {
   {1, UPB_SIZE(4, 8), UPB_SIZE(0, 0), kUpb_NoSub, 9, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
   {2, UPB_SIZE(1, 1), UPB_SIZE(0, 0), kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
   {3, UPB_SIZE(12, 24), UPB_SIZE(1, 1), 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
@@ -49,12 +49,13 @@ static const upb_MiniTable_Field envoy_admin_v3_ClusterStatus__fields[7] = {
   {5, UPB_SIZE(20, 40), UPB_SIZE(2, 2), 2, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
   {6, UPB_SIZE(24, 48), UPB_SIZE(3, 3), 3, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
   {7, UPB_SIZE(28, 56), UPB_SIZE(0, 0), kUpb_NoSub, 9, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+  {8, UPB_SIZE(36, 72), UPB_SIZE(0, 0), kUpb_NoSub, 9, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
 };
 
 const upb_MiniTable envoy_admin_v3_ClusterStatus_msginit = {
   &envoy_admin_v3_ClusterStatus_submsgs[0],
   &envoy_admin_v3_ClusterStatus__fields[0],
-  UPB_SIZE(40, 72), 7, kUpb_ExtMode_NonExtendable, 7, 255, 0,
+  UPB_SIZE(48, 88), 8, kUpb_ExtMode_NonExtendable, 8, 255, 0,
 };
 
 static const upb_MiniTable_Sub envoy_admin_v3_HostStatus_submsgs[6] = {

data/src/core/ext/upb-generated/envoy/admin/v3/clusters.upb.h

@@ -192,6 +192,12 @@ UPB_INLINE void envoy_admin_v3_ClusterStatus_clear_observability_name(const envo
 UPB_INLINE upb_StringView envoy_admin_v3_ClusterStatus_observability_name(const envoy_admin_v3_ClusterStatus* msg) {
   return *UPB_PTR_AT(msg, UPB_SIZE(28, 56), upb_StringView);
 }
+UPB_INLINE void envoy_admin_v3_ClusterStatus_clear_eds_service_name(const envoy_admin_v3_ClusterStatus* msg) {
+  *UPB_PTR_AT(msg, UPB_SIZE(36, 72), upb_StringView) = upb_StringView_FromDataAndSize(NULL, 0);
+}
+UPB_INLINE upb_StringView envoy_admin_v3_ClusterStatus_eds_service_name(const envoy_admin_v3_ClusterStatus* msg) {
+  return *UPB_PTR_AT(msg, UPB_SIZE(36, 72), upb_StringView);
+}
 
 UPB_INLINE void envoy_admin_v3_ClusterStatus_set_name(envoy_admin_v3_ClusterStatus *msg, upb_StringView value) {
   *UPB_PTR_AT(msg, UPB_SIZE(4, 8), upb_StringView) = value;
@@ -253,6 +259,9 @@ UPB_INLINE struct envoy_config_cluster_v3_CircuitBreakers* envoy_admin_v3_Cluste
 UPB_INLINE void envoy_admin_v3_ClusterStatus_set_observability_name(envoy_admin_v3_ClusterStatus *msg, upb_StringView value) {
   *UPB_PTR_AT(msg, UPB_SIZE(28, 56), upb_StringView) = value;
 }
+UPB_INLINE void envoy_admin_v3_ClusterStatus_set_eds_service_name(envoy_admin_v3_ClusterStatus *msg, upb_StringView value) {
+  *UPB_PTR_AT(msg, UPB_SIZE(36, 72), upb_StringView) = value;
+}
 
 /* envoy.admin.v3.HostStatus */
 

data/src/core/ext/upb-generated/envoy/admin/v3/config_dump_shared.upb.c

@@ -319,7 +319,41 @@ const upb_MiniTable envoy_admin_v3_EndpointsConfigDump_DynamicEndpointConfig_msg
   UPB_SIZE(32, 48), 5, kUpb_ExtMode_NonExtendable, 5, 255, 0,
 };
 
-static const upb_MiniTable *messages_layout[17] = {
+static const upb_MiniTable_Sub envoy_admin_v3_EcdsConfigDump_submsgs[1] = {
+  {.submsg = &envoy_admin_v3_EcdsConfigDump_EcdsFilterConfig_msginit},
+};
+
+static const upb_MiniTable_Field envoy_admin_v3_EcdsConfigDump__fields[1] = {
+  {1, UPB_SIZE(0, 0), UPB_SIZE(0, 0), 0, 11, kUpb_FieldMode_Array | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable envoy_admin_v3_EcdsConfigDump_msginit = {
+  &envoy_admin_v3_EcdsConfigDump_submsgs[0],
+  &envoy_admin_v3_EcdsConfigDump__fields[0],
+  UPB_SIZE(8, 8), 1, kUpb_ExtMode_NonExtendable, 1, 255, 0,
+};
+
+static const upb_MiniTable_Sub envoy_admin_v3_EcdsConfigDump_EcdsFilterConfig_submsgs[3] = {
+  {.submsg = &google_protobuf_Any_msginit},
+  {.submsg = &google_protobuf_Timestamp_msginit},
+  {.submsg = &envoy_admin_v3_UpdateFailureState_msginit},
+};
+
+static const upb_MiniTable_Field envoy_admin_v3_EcdsConfigDump_EcdsFilterConfig__fields[5] = {
+  {1, UPB_SIZE(8, 8), UPB_SIZE(0, 0), kUpb_NoSub, 9, kUpb_FieldMode_Scalar | (kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)},
+  {2, UPB_SIZE(16, 24), UPB_SIZE(1, 1), 0, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+  {3, UPB_SIZE(20, 32), UPB_SIZE(2, 2), 1, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+  {4, UPB_SIZE(24, 40), UPB_SIZE(3, 3), 2, 11, kUpb_FieldMode_Scalar | (kUpb_FieldRep_Pointer << kUpb_FieldRep_Shift)},
+  {5, UPB_SIZE(4, 4), UPB_SIZE(0, 0), kUpb_NoSub, 5, kUpb_FieldMode_Scalar | (kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable envoy_admin_v3_EcdsConfigDump_EcdsFilterConfig_msginit = {
+  &envoy_admin_v3_EcdsConfigDump_EcdsFilterConfig_submsgs[0],
+  &envoy_admin_v3_EcdsConfigDump_EcdsFilterConfig__fields[0],
+  UPB_SIZE(32, 48), 5, kUpb_ExtMode_NonExtendable, 5, 255, 0,
+};
+
+static const upb_MiniTable *messages_layout[19] = {
   &envoy_admin_v3_UpdateFailureState_msginit,
   &envoy_admin_v3_ListenersConfigDump_msginit,
   &envoy_admin_v3_ListenersConfigDump_StaticListener_msginit,
@@ -337,13 +371,15 @@ static const upb_MiniTable *messages_layout[17] = {
   &envoy_admin_v3_EndpointsConfigDump_msginit,
   &envoy_admin_v3_EndpointsConfigDump_StaticEndpointConfig_msginit,
   &envoy_admin_v3_EndpointsConfigDump_DynamicEndpointConfig_msginit,
+  &envoy_admin_v3_EcdsConfigDump_msginit,
+  &envoy_admin_v3_EcdsConfigDump_EcdsFilterConfig_msginit,
 };
 
 const upb_MiniTable_File envoy_admin_v3_config_dump_shared_proto_upb_file_layout = {
   messages_layout,
   NULL,
   NULL,
-  17,
+  19,
   0,
   0,
 };