grpc 1.37.1 → 1.40.0.pre1

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

@@ -20,6 +20,8 @@
 
 #include "src/core/ext/transport/chttp2/transport/varint.h"
 
+#include "absl/base/attributes.h"
+
 uint32_t grpc_chttp2_hpack_varint_length(uint32_t tail_value) {
   if (tail_value < (1 << 7)) {
     return 2;
@@ -39,16 +41,16 @@ void grpc_chttp2_hpack_write_varint_tail(uint32_t tail_value, uint8_t* target,
   switch (tail_length) {
     case 5:
       target[4] = static_cast<uint8_t>((tail_value >> 28) | 0x80);
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case 4:
       target[3] = static_cast<uint8_t>((tail_value >> 21) | 0x80);
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case 3:
       target[2] = static_cast<uint8_t>((tail_value >> 14) | 0x80);
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case 2:
       target[1] = static_cast<uint8_t>((tail_value >> 7) | 0x80);
-    /* fallthrough */
+      ABSL_FALLTHROUGH_INTENDED;
     case 1:
       target[0] = static_cast<uint8_t>((tail_value) | 0x80);
   }

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

@@ -39,7 +39,7 @@ static void add_to_write_list(grpc_chttp2_write_cb** list,
 }
 
 static void finish_write_cb(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
-                            grpc_chttp2_write_cb* cb, grpc_error* error) {
+                            grpc_chttp2_write_cb* cb, grpc_error_handle error) {
   grpc_chttp2_complete_closure_step(t, s, &cb->closure, error,
                                     "finish_write_cb");
   cb->next = t->write_cb_pool;
@@ -75,6 +75,10 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
     }
     return;
   }
+  // InvalidateNow to avoid getting stuck re-initializing the ping timer
+  // in a loop while draining the currently-held combiner. Also see
+  // https://github.com/grpc/grpc/issues/26079.
+  grpc_core::ExecCtx::Get()->InvalidateNow();
   grpc_millis now = grpc_core::ExecCtx::Get()->Now();
 
   grpc_millis next_allowed_ping_interval =
@@ -134,7 +138,7 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
 
 static bool update_list(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
                         int64_t send_bytes, grpc_chttp2_write_cb** list,
-                        int64_t* ctr, grpc_error* error) {
+                        int64_t* ctr, grpc_error_handle error) {
   bool sched_any = false;
   grpc_chttp2_write_cb* cb = *list;
   *list = nullptr;
@@ -678,7 +682,7 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
   return ctx.Result();
 }
 
-void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error* error) {
+void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
   GPR_TIMER_SCOPE("grpc_chttp2_end_write", 0);
   grpc_chttp2_stream* s;
 

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

@@ -50,15 +50,15 @@ grpc_slice g_fake_auth_key;
 grpc_slice g_fake_auth_value;
 
 struct inproc_stream;
-bool cancel_stream_locked(inproc_stream* s, grpc_error* error);
-void maybe_process_ops_locked(inproc_stream* s, grpc_error* error);
-void op_state_machine_locked(inproc_stream* s, grpc_error* error);
+bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error);
+void maybe_process_ops_locked(inproc_stream* s, grpc_error_handle error);
+void op_state_machine_locked(inproc_stream* s, grpc_error_handle error);
 void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
                   bool is_initial);
-grpc_error* fill_in_metadata(inproc_stream* s,
-                             const grpc_metadata_batch* metadata,
-                             uint32_t flags, grpc_metadata_batch* out_md,
-                             uint32_t* outflags, bool* markfilled);
+grpc_error_handle fill_in_metadata(inproc_stream* s,
+                                   const grpc_metadata_batch* metadata,
+                                   uint32_t flags, grpc_metadata_batch* out_md,
+                                   uint32_t* outflags, bool* markfilled);
 
 struct shared_mu {
   shared_mu() {
@@ -239,7 +239,7 @@ struct inproc_stream {
   grpc_millis write_buffer_deadline = GRPC_MILLIS_INF_FUTURE;
   grpc_metadata_batch write_buffer_trailing_md;
   bool write_buffer_trailing_md_filled = false;
-  grpc_error* write_buffer_cancel_error = GRPC_ERROR_NONE;
+  grpc_error_handle write_buffer_cancel_error = GRPC_ERROR_NONE;
 
   struct inproc_stream* other_side;
   bool other_side_closed = false;               // won't talk anymore
@@ -270,8 +270,8 @@ struct inproc_stream {
 
   bool closed = false;
 
-  grpc_error* cancel_self_error = GRPC_ERROR_NONE;
-  grpc_error* cancel_other_error = GRPC_ERROR_NONE;
+  grpc_error_handle cancel_self_error = GRPC_ERROR_NONE;
+  grpc_error_handle cancel_other_error = GRPC_ERROR_NONE;
 
   grpc_millis deadline = GRPC_MILLIS_INF_FUTURE;
 
@@ -293,10 +293,10 @@ void log_metadata(const grpc_metadata_batch* md_batch, bool is_client,
   }
 }
 
-grpc_error* fill_in_metadata(inproc_stream* s,
-                             const grpc_metadata_batch* metadata,
-                             uint32_t flags, grpc_metadata_batch* out_md,
-                             uint32_t* outflags, bool* markfilled) {
+grpc_error_handle fill_in_metadata(inproc_stream* s,
+                                   const grpc_metadata_batch* metadata,
+                                   uint32_t flags, grpc_metadata_batch* out_md,
+                                   uint32_t* outflags, bool* markfilled) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_inproc_trace)) {
     log_metadata(metadata, s->t->is_client, outflags != nullptr);
   }
@@ -307,7 +307,7 @@ grpc_error* fill_in_metadata(inproc_stream* s,
   if (markfilled != nullptr) {
     *markfilled = true;
   }
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   for (grpc_linked_mdelem* elem = metadata->list.head;
        (elem != nullptr) && (error == GRPC_ERROR_NONE); elem = elem->next) {
     grpc_linked_mdelem* nelem =
@@ -374,7 +374,7 @@ void close_other_side_locked(inproc_stream* s, const char* reason) {
 // this stream_op_batch is only one of the pending operations for this
 // stream. This is called when one of the pending operations for the stream
 // is done and about to be NULLed out
-void complete_if_batch_end_locked(inproc_stream* s, grpc_error* error,
+void complete_if_batch_end_locked(inproc_stream* s, grpc_error_handle error,
                                   grpc_transport_stream_op_batch* op,
                                   const char* msg) {
   int is_sm = static_cast<int>(op == s->send_message_op);
@@ -388,20 +388,21 @@ void complete_if_batch_end_locked(inproc_stream* s, grpc_error* error,
   int is_rtm = static_cast<int>(op == s->recv_trailing_md_op);
 
   if ((is_sm + is_stm + is_rim + is_rm + is_rtm) == 1) {
-    INPROC_LOG(GPR_INFO, "%s %p %p %p", msg, s, op, error);
+    INPROC_LOG(GPR_INFO, "%s %p %p %s", msg, s, op,
+               grpc_error_std_string(error).c_str());
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, op->on_complete,
                             GRPC_ERROR_REF(error));
   }
 }
 
-void maybe_process_ops_locked(inproc_stream* s, grpc_error* error) {
+void maybe_process_ops_locked(inproc_stream* s, grpc_error_handle error) {
   if (s && (error != GRPC_ERROR_NONE || s->ops_needed)) {
     s->ops_needed = false;
     op_state_machine_locked(s, error);
   }
 }
 
-void fail_helper_locked(inproc_stream* s, grpc_error* error) {
+void fail_helper_locked(inproc_stream* s, grpc_error_handle error) {
   INPROC_LOG(GPR_INFO, "op_state_machine %p fail_helper", s);
   // If we're failing this side, we need to make sure that
   // we also send or have already sent trailing metadata
@@ -431,7 +432,7 @@ void fail_helper_locked(inproc_stream* s, grpc_error* error) {
     }
   }
   if (s->recv_initial_md_op) {
-    grpc_error* err;
+    grpc_error_handle err;
     if (!s->t->is_client) {
       // If this is a server, provide initial metadata with a path and authority
       // since it expects that as well as no error yet
@@ -468,8 +469,9 @@ void fail_helper_locked(inproc_stream* s, grpc_error* error) {
            .trailing_metadata_available = true;
     }
     INPROC_LOG(GPR_INFO,
-               "fail_helper %p scheduling initial-metadata-ready %p %p", s,
-               error, err);
+               "fail_helper %p scheduling initial-metadata-ready %s %s", s,
+               grpc_error_std_string(error).c_str(),
+               grpc_error_std_string(err).c_str());
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION,
         s->recv_initial_md_op->payload->recv_initial_metadata
@@ -483,8 +485,13 @@ void fail_helper_locked(inproc_stream* s, grpc_error* error) {
     s->recv_initial_md_op = nullptr;
   }
   if (s->recv_message_op) {
-    INPROC_LOG(GPR_INFO, "fail_helper %p scheduling message-ready %p", s,
-               error);
+    INPROC_LOG(GPR_INFO, "fail_helper %p scheduling message-ready %s", s,
+               grpc_error_std_string(error).c_str());
+    if (s->recv_message_op->payload->recv_message
+            .call_failed_before_recv_message != nullptr) {
+      *s->recv_message_op->payload->recv_message
+           .call_failed_before_recv_message = true;
+    }
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION,
         s->recv_message_op->payload->recv_message.recv_message_ready,
@@ -508,15 +515,15 @@ void fail_helper_locked(inproc_stream* s, grpc_error* error) {
     s->send_trailing_md_op = nullptr;
   }
   if (s->recv_trailing_md_op) {
-    INPROC_LOG(GPR_INFO, "fail_helper %p scheduling trailing-metadata-ready %p",
-               s, error);
+    INPROC_LOG(GPR_INFO, "fail_helper %p scheduling trailing-metadata-ready %s",
+               s, grpc_error_std_string(error).c_str());
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION,
         s->recv_trailing_md_op->payload->recv_trailing_metadata
             .recv_trailing_metadata_ready,
         GRPC_ERROR_REF(error));
-    INPROC_LOG(GPR_INFO, "fail_helper %p scheduling trailing-md-on-complete %p",
-               s, error);
+    INPROC_LOG(GPR_INFO, "fail_helper %p scheduling trailing-md-on-complete %s",
+               s, grpc_error_std_string(error).c_str());
     complete_if_batch_end_locked(
         s, error, s->recv_trailing_md_op,
         "fail_helper scheduling recv-trailing-metadata-on-complete");
@@ -550,7 +557,7 @@ void message_transfer_locked(inproc_stream* sender, inproc_stream* receiver) {
     GPR_ASSERT(
         sender->send_message_op->payload->send_message.send_message->Next(
             SIZE_MAX, &unused));
-    grpc_error* error =
+    grpc_error_handle error =
         sender->send_message_op->payload->send_message.send_message->Pull(
             &message_slice);
     if (error != GRPC_ERROR_NONE) {
@@ -583,13 +590,13 @@ void message_transfer_locked(inproc_stream* sender, inproc_stream* receiver) {
   sender->send_message_op = nullptr;
 }
 
-void op_state_machine_locked(inproc_stream* s, grpc_error* error) {
+void op_state_machine_locked(inproc_stream* s, grpc_error_handle error) {
   // This function gets called when we have contents in the unprocessed reads
   // Get what we want based on our ops wanted
   // Schedule our appropriate closures
   // and then return to ops_needed state if still needed
 
-  grpc_error* new_err = GRPC_ERROR_NONE;
+  grpc_error_handle new_err = GRPC_ERROR_NONE;
 
   bool needs_close = false;
 
@@ -685,8 +692,8 @@ void op_state_machine_locked(inproc_stream* s, grpc_error* error) {
       INPROC_LOG(
           GPR_INFO,
           "op_state_machine %p scheduling on_complete errors for already "
-          "recvd initial md %p",
-          s, new_err);
+          "recvd initial md %s",
+          s, grpc_error_std_string(new_err).c_str());
       fail_helper_locked(s, GRPC_ERROR_REF(new_err));
       goto done;
     }
@@ -710,8 +717,8 @@ void op_state_machine_locked(inproc_stream* s, grpc_error* error) {
       grpc_metadata_batch_clear(&s->to_read_initial_md);
       s->to_read_initial_md_filled = false;
       INPROC_LOG(GPR_INFO,
-                 "op_state_machine %p scheduling initial-metadata-ready %p", s,
-                 new_err);
+                 "op_state_machine %p scheduling initial-metadata-ready %s", s,
+                 grpc_error_std_string(new_err).c_str());
       grpc_core::ExecCtx::Run(
           DEBUG_LOCATION,
           s->recv_initial_md_op->payload->recv_initial_metadata
@@ -724,8 +731,8 @@ void op_state_machine_locked(inproc_stream* s, grpc_error* error) {
 
       if (new_err != GRPC_ERROR_NONE) {
         INPROC_LOG(GPR_INFO,
-                   "op_state_machine %p scheduling on_complete errors2 %p", s,
-                   new_err);
+                   "op_state_machine %p scheduling on_complete errors2 %s", s,
+                   grpc_error_std_string(new_err).c_str());
         fail_helper_locked(s, GRPC_ERROR_REF(new_err));
         goto done;
       }
@@ -753,8 +760,8 @@ void op_state_machine_locked(inproc_stream* s, grpc_error* error) {
         INPROC_LOG(
             GPR_INFO,
             "op_state_machine %p scheduling on_complete errors for already "
-            "recvd trailing md %p",
-            s, new_err);
+            "recvd trailing md %s",
+            s, grpc_error_std_string(new_err).c_str());
         fail_helper_locked(s, GRPC_ERROR_REF(new_err));
         goto done;
       }
@@ -801,8 +808,8 @@ void op_state_machine_locked(inproc_stream* s, grpc_error* error) {
       //     a final status, so don't mark this op complete)
       if (s->t->is_client || s->trailing_md_sent) {
         INPROC_LOG(GPR_INFO,
-                   "op_state_machine %p scheduling trailing-md-on-complete %p",
-                   s, new_err);
+                   "op_state_machine %p scheduling trailing-md-on-complete %s",
+                   s, grpc_error_std_string(new_err).c_str());
         grpc_core::ExecCtx::Run(
             DEBUG_LOCATION,
             s->recv_trailing_md_op->payload->recv_trailing_metadata
@@ -816,8 +823,8 @@ void op_state_machine_locked(inproc_stream* s, grpc_error* error) {
       } else {
         INPROC_LOG(GPR_INFO,
                    "op_state_machine %p server needs to delay handling "
-                   "trailing-md-on-complete %p",
-                   s, new_err);
+                   "trailing-md-on-complete %s",
+                   s, grpc_error_std_string(new_err).c_str());
       }
     } else if (!s->trailing_md_recvd) {
       INPROC_LOG(
@@ -830,8 +837,8 @@ void op_state_machine_locked(inproc_stream* s, grpc_error* error) {
     // In this case, we don't care to receive the write-close from the client
     // because we have already sent status and the RPC is over as far as we
     // are concerned.
-    INPROC_LOG(GPR_INFO, "op_state_machine %p scheduling trailing-md-ready %p",
-               s, new_err);
+    INPROC_LOG(GPR_INFO, "op_state_machine %p scheduling trailing-md-ready %s",
+               s, grpc_error_std_string(new_err).c_str());
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION,
         s->recv_trailing_md_op->payload->recv_trailing_metadata
@@ -887,9 +894,10 @@ done:
   GRPC_ERROR_UNREF(new_err);
 }
 
-bool cancel_stream_locked(inproc_stream* s, grpc_error* error) {
+bool cancel_stream_locked(inproc_stream* s, grpc_error_handle error) {
   bool ret = false;  // was the cancel accepted
-  INPROC_LOG(GPR_INFO, "cancel_stream %p with %s", s, grpc_error_string(error));
+  INPROC_LOG(GPR_INFO, "cancel_stream %p with %s", s,
+             grpc_error_std_string(error).c_str());
   if (s->cancel_self_error == GRPC_ERROR_NONE) {
     ret = true;
     s->cancel_self_error = GRPC_ERROR_REF(error);
@@ -943,7 +951,7 @@ bool cancel_stream_locked(inproc_stream* s, grpc_error* error) {
   return ret;
 }
 
-void do_nothing(void* /*arg*/, grpc_error* /*error*/) {}
+void do_nothing(void* /*arg*/, grpc_error_handle /*error*/) {}
 
 void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
                        grpc_transport_stream_op_batch* op) {
@@ -962,7 +970,7 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
                    s->t->is_client, false);
     }
   }
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   grpc_closure* on_complete = op->on_complete;
   // TODO(roth): This is a hack needed because we use data inside of the
   // closure itself to do the barrier calculation (i.e., to ensure that
@@ -1090,8 +1098,8 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
         }
         INPROC_LOG(
             GPR_INFO,
-            "perform_stream_op error %p scheduling initial-metadata-ready %p",
-            s, error);
+            "perform_stream_op error %p scheduling initial-metadata-ready %s",
+            s, grpc_error_std_string(error).c_str());
         grpc_core::ExecCtx::Run(
             DEBUG_LOCATION,
             op->payload->recv_initial_metadata.recv_initial_metadata_ready,
@@ -1100,8 +1108,12 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
       if (op->recv_message) {
         INPROC_LOG(
             GPR_INFO,
-            "perform_stream_op error %p scheduling recv message-ready %p", s,
-            error);
+            "perform_stream_op error %p scheduling recv message-ready %s", s,
+            grpc_error_std_string(error).c_str());
+        if (op->payload->recv_message.call_failed_before_recv_message !=
+            nullptr) {
+          *op->payload->recv_message.call_failed_before_recv_message = true;
+        }
         grpc_core::ExecCtx::Run(DEBUG_LOCATION,
                                 op->payload->recv_message.recv_message_ready,
                                 GRPC_ERROR_REF(error));
@@ -1109,16 +1121,16 @@ void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
       if (op->recv_trailing_metadata) {
         INPROC_LOG(
             GPR_INFO,
-            "perform_stream_op error %p scheduling trailing-metadata-ready %p",
-            s, error);
+            "perform_stream_op error %p scheduling trailing-metadata-ready %s",
+            s, grpc_error_std_string(error).c_str());
         grpc_core::ExecCtx::Run(
             DEBUG_LOCATION,
             op->payload->recv_trailing_metadata.recv_trailing_metadata_ready,
             GRPC_ERROR_REF(error));
       }
     }
-    INPROC_LOG(GPR_INFO, "perform_stream_op %p scheduling on_complete %p", s,
-               error);
+    INPROC_LOG(GPR_INFO, "perform_stream_op %p scheduling on_complete %s", s,
+               grpc_error_std_string(error).c_str());
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_complete, GRPC_ERROR_REF(error));
   }
   gpr_mu_unlock(mu);
@@ -1293,7 +1305,7 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
                            client_args);
 
   // TODO(ncteisen): design and support channelz GetSocket for inproc.
-  grpc_error* error = server->core_server->SetupTransport(
+  grpc_error_handle error = server->core_server->SetupTransport(
       server_transport, nullptr, server_args, nullptr);
   grpc_channel* channel = nullptr;
   if (error == GRPC_ERROR_NONE) {
@@ -1303,7 +1315,7 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
     if (error != GRPC_ERROR_NONE) {
       GPR_ASSERT(!channel);
       gpr_log(GPR_ERROR, "Failed to create client channel: %s",
-              grpc_error_string(error));
+              grpc_error_std_string(error).c_str());
       intptr_t integer;
       grpc_status_code status = GRPC_STATUS_INTERNAL;
       if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &integer)) {
@@ -1318,7 +1330,7 @@ grpc_channel* grpc_inproc_channel_create(grpc_server* server,
   } else {
     GPR_ASSERT(!channel);
     gpr_log(GPR_ERROR, "Failed to create server channel: %s",
-            grpc_error_string(error));
+            grpc_error_std_string(error).c_str());
     intptr_t integer;
     grpc_status_code status = GRPC_STATUS_INTERNAL;
     if (grpc_error_get_int(error, GRPC_ERROR_INT_GRPC_STATUS, &integer)) {

data/src/core/ext/upb-generated/envoy/config/bootstrap/v3/bootstrap.upb.c

@@ -9,12 +9,14 @@
 #include <stddef.h>
 #include "upb/msg.h"
 #include "envoy/config/bootstrap/v3/bootstrap.upb.h"
+#include "envoy/config/accesslog/v3/accesslog.upb.h"
 #include "envoy/config/cluster/v3/cluster.upb.h"
 #include "envoy/config/core/v3/address.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/config/core/v3/config_source.upb.h"
 #include "envoy/config/core/v3/event_service_config.upb.h"
 #include "envoy/config/core/v3/extension.upb.h"
+#include "envoy/config/core/v3/resolver.upb.h"
 #include "envoy/config/core/v3/socket_option.upb.h"
 #include "envoy/config/listener/v3/listener.upb.h"
 #include "envoy/config/metrics/v3/stats.upb.h"
@@ -25,6 +27,7 @@
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/struct.upb.h"
 #include "google/protobuf/wrappers.upb.h"
+#include "envoy/annotations/deprecation.upb.h"
 #include "udpa/annotations/migrate.upb.h"
 #include "udpa/annotations/security.upb.h"
 #include "udpa/annotations/status.upb.h"
@@ -33,18 +36,20 @@
 
 #include "upb/port_def.inc"
 
-static const upb_msglayout *const envoy_config_bootstrap_v3_Bootstrap_submsgs[19] = {
+static const upb_msglayout *const envoy_config_bootstrap_v3_Bootstrap_submsgs[21] = {
   &envoy_config_bootstrap_v3_Admin_msginit,
   &envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry_msginit,
   &envoy_config_bootstrap_v3_Bootstrap_DynamicResources_msginit,
   &envoy_config_bootstrap_v3_Bootstrap_StaticResources_msginit,
   &envoy_config_bootstrap_v3_ClusterManager_msginit,
+  &envoy_config_bootstrap_v3_CustomInlineHeader_msginit,
   &envoy_config_bootstrap_v3_FatalAction_msginit,
   &envoy_config_bootstrap_v3_LayeredRuntime_msginit,
   &envoy_config_bootstrap_v3_Watchdog_msginit,
   &envoy_config_bootstrap_v3_Watchdogs_msginit,
   &envoy_config_core_v3_ApiConfigSource_msginit,
   &envoy_config_core_v3_ConfigSource_msginit,
+  &envoy_config_core_v3_DnsResolutionConfig_msginit,
   &envoy_config_core_v3_Node_msginit,
   &envoy_config_core_v3_TypedExtensionConfig_msginit,
   &envoy_config_metrics_v3_StatsConfig_msginit,
@@ -55,40 +60,43 @@ static const upb_msglayout *const envoy_config_bootstrap_v3_Bootstrap_submsgs[19
   &google_protobuf_UInt64Value_msginit,
 };
 
-static const upb_msglayout_field envoy_config_bootstrap_v3_Bootstrap__fields[27] = {
-  {1, UPB_SIZE(28, 56), 1, 11, 11, 1},
-  {2, UPB_SIZE(32, 64), 2, 3, 11, 1},
-  {3, UPB_SIZE(36, 72), 3, 2, 11, 1},
-  {4, UPB_SIZE(40, 80), 4, 4, 11, 1},
-  {5, UPB_SIZE(4, 8), 0, 0, 9, 1},
-  {6, UPB_SIZE(88, 176), 0, 14, 11, 3},
-  {7, UPB_SIZE(44, 88), 5, 17, 11, 1},
-  {8, UPB_SIZE(48, 96), 6, 7, 11, 1},
-  {9, UPB_SIZE(52, 104), 7, 16, 11, 1},
-  {12, UPB_SIZE(56, 112), 8, 0, 11, 1},
-  {13, UPB_SIZE(60, 120), 9, 13, 11, 1},
-  {14, UPB_SIZE(64, 128), 10, 9, 11, 1},
-  {15, UPB_SIZE(68, 136), 11, 15, 11, 1},
-  {16, UPB_SIZE(2, 2), 0, 0, 8, 1},
-  {17, UPB_SIZE(72, 144), 12, 6, 11, 1},
-  {18, UPB_SIZE(12, 24), 0, 0, 9, 1},
-  {19, UPB_SIZE(76, 152), 13, 18, 11, 1},
-  {20, UPB_SIZE(3, 3), 0, 0, 8, 1},
-  {21, UPB_SIZE(92, 184), 0, 12, 11, 3},
-  {22, UPB_SIZE(96, 192), 0, 10, 11, 3},
-  {23, UPB_SIZE(80, 160), 14, 10, 11, 1},
-  {24, UPB_SIZE(20, 40), 0, 0, 9, 1},
-  {25, UPB_SIZE(100, 200), 0, 1, 11, _UPB_LABEL_MAP},
-  {26, UPB_SIZE(104, 208), 0, 0, 9, 3},
-  {27, UPB_SIZE(84, 168), 15, 8, 11, 1},
-  {28, UPB_SIZE(108, 216), 0, 5, 11, 3},
-  {29, UPB_SIZE(112, 224), UPB_SIZE(-117, -229), 0, 8, 1},
+static const upb_msglayout_field envoy_config_bootstrap_v3_Bootstrap__fields[30] = {
+  {1, UPB_SIZE(32, 56), 1, 13, 11, 1},
+  {2, UPB_SIZE(36, 64), 2, 3, 11, 1},
+  {3, UPB_SIZE(40, 72), 3, 2, 11, 1},
+  {4, UPB_SIZE(44, 80), 4, 4, 11, 1},
+  {5, UPB_SIZE(8, 8), 0, 0, 9, 1},
+  {6, UPB_SIZE(100, 192), 0, 16, 11, 3},
+  {7, UPB_SIZE(48, 88), 5, 19, 11, 1},
+  {8, UPB_SIZE(52, 96), 6, 8, 11, 1},
+  {9, UPB_SIZE(56, 104), 7, 18, 11, 1},
+  {12, UPB_SIZE(60, 112), 8, 0, 11, 1},
+  {13, UPB_SIZE(64, 120), 9, 15, 11, 1},
+  {14, UPB_SIZE(68, 128), 10, 10, 11, 1},
+  {15, UPB_SIZE(72, 136), 11, 17, 11, 1},
+  {16, UPB_SIZE(3, 3), 0, 0, 8, 1},
+  {17, UPB_SIZE(76, 144), 12, 7, 11, 1},
+  {18, UPB_SIZE(16, 24), 0, 0, 9, 1},
+  {19, UPB_SIZE(80, 152), 13, 20, 11, 1},
+  {20, UPB_SIZE(4, 4), 0, 0, 8, 1},
+  {21, UPB_SIZE(104, 200), 0, 14, 11, 3},
+  {22, UPB_SIZE(108, 208), 0, 11, 11, 3},
+  {23, UPB_SIZE(84, 160), 14, 11, 11, 1},
+  {24, UPB_SIZE(24, 40), 0, 0, 9, 1},
+  {25, UPB_SIZE(112, 216), 0, 1, 11, _UPB_LABEL_MAP},
+  {26, UPB_SIZE(116, 224), 0, 0, 9, 3},
+  {27, UPB_SIZE(88, 168), 15, 9, 11, 1},
+  {28, UPB_SIZE(120, 232), 0, 6, 11, 3},
+  {29, UPB_SIZE(128, 248), UPB_SIZE(-133, -253), 0, 8, 1},
+  {30, UPB_SIZE(92, 176), 16, 12, 11, 1},
+  {31, UPB_SIZE(96, 184), 17, 14, 11, 1},
+  {32, UPB_SIZE(124, 240), 0, 5, 11, 3},
 };
 
 const upb_msglayout envoy_config_bootstrap_v3_Bootstrap_msginit = {
   &envoy_config_bootstrap_v3_Bootstrap_submsgs[0],
   &envoy_config_bootstrap_v3_Bootstrap__fields[0],
-  UPB_SIZE(120, 240), 27, false, 255,
+  UPB_SIZE(136, 256), 30, false, 255,
 };
 
 static const upb_msglayout *const envoy_config_bootstrap_v3_Bootstrap_StaticResources_submsgs[3] = {
@@ -143,22 +151,24 @@ const upb_msglayout envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInsta
   UPB_SIZE(16, 32), 2, false, 255,
 };
 
-static const upb_msglayout *const envoy_config_bootstrap_v3_Admin_submsgs[2] = {
+static const upb_msglayout *const envoy_config_bootstrap_v3_Admin_submsgs[3] = {
+  &envoy_config_accesslog_v3_AccessLog_msginit,
   &envoy_config_core_v3_Address_msginit,
   &envoy_config_core_v3_SocketOption_msginit,
 };
 
-static const upb_msglayout_field envoy_config_bootstrap_v3_Admin__fields[4] = {
+static const upb_msglayout_field envoy_config_bootstrap_v3_Admin__fields[5] = {
   {1, UPB_SIZE(4, 8), 0, 0, 9, 1},
   {2, UPB_SIZE(12, 24), 0, 0, 9, 1},
-  {3, UPB_SIZE(20, 40), 1, 0, 11, 1},
-  {4, UPB_SIZE(24, 48), 0, 1, 11, 3},
+  {3, UPB_SIZE(20, 40), 1, 1, 11, 1},
+  {4, UPB_SIZE(24, 48), 0, 2, 11, 3},
+  {5, UPB_SIZE(28, 56), 0, 0, 11, 3},
 };
 
 const upb_msglayout envoy_config_bootstrap_v3_Admin_msginit = {
   &envoy_config_bootstrap_v3_Admin_submsgs[0],
   &envoy_config_bootstrap_v3_Admin__fields[0],
-  UPB_SIZE(32, 64), 4, false, 255,
+  UPB_SIZE(32, 64), 5, false, 255,
 };
 
 static const upb_msglayout *const envoy_config_bootstrap_v3_ClusterManager_submsgs[3] = {
@@ -346,5 +356,16 @@ const upb_msglayout envoy_config_bootstrap_v3_LayeredRuntime_msginit = {
   UPB_SIZE(8, 8), 1, false, 255,
 };
 
+static const upb_msglayout_field envoy_config_bootstrap_v3_CustomInlineHeader__fields[2] = {
+  {1, UPB_SIZE(4, 8), 0, 0, 9, 1},
+  {2, UPB_SIZE(0, 0), 0, 0, 14, 1},
+};
+
+const upb_msglayout envoy_config_bootstrap_v3_CustomInlineHeader_msginit = {
+  NULL,
+  &envoy_config_bootstrap_v3_CustomInlineHeader__fields[0],
+  UPB_SIZE(16, 32), 2, false, 255,
+};
+
 #include "upb/port_undef.inc"