grpc 1.83.0 → 1.83.2

data/src/core/ext/filters/http/message_compress/compression_filter.cc

@@ -21,6 +21,7 @@
 #include <grpc/support/port_platform.h>
 #include <inttypes.h>
 
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <optional>
@@ -44,6 +45,7 @@
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/call_tracer.h"
+#include "src/core/transport/message_size_service_config.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/latent_see.h"
 #include "absl/status/status.h"
@@ -75,8 +77,6 @@ ServerCompressionFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
 
 ChannelCompression::ChannelCompression(const ChannelArgs& args)
     : max_recv_size_(GetMaxRecvSizeFromChannelArgs(args)),
-      message_size_service_config_parser_index_(
-          MessageSizeParser::ParserIndex()),
       default_compression_algorithm_(
           DefaultCompressionAlgorithmFromChannelArgs(args).value_or(
               GRPC_COMPRESS_NONE)),
@@ -118,26 +118,25 @@ MessageHandle ChannelCompression::CompressMessage(
     return message;
   }
   // Try to compress the payload.
-  SliceBuffer tmp;
-  SliceBuffer* payload = message->payload();
-  bool did_compress = grpc_msg_compress(algorithm, payload->c_slice_buffer(),
-                                        tmp.c_slice_buffer());
+  std::optional<SliceBuffer> compressed =
+      MessageCompress(algorithm, *message->payload());
+
   // If we achieved compression send it as compressed, otherwise send it as (to
   // avoid spending cycles on the receiver decompressing).
-  if (did_compress) {
+  if (compressed.has_value()) {
     if (GRPC_TRACE_FLAG_ENABLED(compression)) {
       const char* algo_name;
-      const size_t before_size = payload->Length();
-      const size_t after_size = tmp.Length();
+      GRPC_CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
+      const size_t before_size = message->payload()->Length();
+      const size_t after_size = compressed->Length();
       const float savings_ratio = 1.0f - (static_cast<float>(after_size) /
                                           static_cast<float>(before_size));
-      GRPC_CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
       LOG(INFO) << absl::StrFormat(
           "Compressed[%s] %" PRIuPTR " bytes vs. %" PRIuPTR
           " bytes (%.2f%% savings)",
           algo_name, before_size, after_size, 100 * savings_ratio);
     }
-    tmp.Swap(payload);
+    *message->payload() = std::move(*compressed);
     flags |= GRPC_WRITE_INTERNAL_COMPRESS;
     if (call_tracer != nullptr) {
       call_tracer->RecordSendCompressedMessage(*message);
@@ -148,7 +147,7 @@ MessageHandle ChannelCompression::CompressMessage(
       GRPC_CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
       LOG(INFO) << "Algorithm '" << algo_name
                 << "' enabled but decided not to compress. Input size: "
-                << payload->Length();
+                << message->payload()->Length();
     }
   }
   return message;
@@ -180,15 +179,17 @@ absl::StatusOr<MessageHandle> ChannelCompression::DecompressMessage(
     return std::move(message);
   }
   // Try to decompress the payload.
-  SliceBuffer decompressed_slices;
-  if (grpc_msg_decompress(args.algorithm, message->payload()->c_slice_buffer(),
-                          decompressed_slices.c_slice_buffer()) == 0) {
-    return absl::InternalError(
-        absl::StrCat("Unexpected error decompressing data for algorithm ",
-                     CompressionAlgorithmAsString(args.algorithm)));
+  std::optional<uint32_t> max_output_size = IsMessageSizeRefactoringEnabled()
+                                                ? args.max_recv_message_length
+                                                : std::nullopt;
+  absl::StatusOr<SliceBuffer> decompressed_slices =
+      MessageDecompress(args.algorithm, *message->payload(), max_output_size);
+  if (!decompressed_slices.ok()) {
+    return decompressed_slices.status();
   }
-  // Swap the decompressed slices into the message.
-  message->payload()->Swap(&decompressed_slices);
+
+  // Move the decompressed slices into the message.
+  *message->payload() = std::move(*decompressed_slices);
   message->mutable_flags() &= ~GRPC_WRITE_INTERNAL_COMPRESS;
   message->mutable_flags() |= GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED;
   if (call_tracer != nullptr) {
@@ -213,18 +214,10 @@ grpc_compression_algorithm ChannelCompression::HandleOutgoingMetadata(
 ChannelCompression::DecompressArgs ChannelCompression::HandleIncomingMetadata(
     const grpc_metadata_batch& incoming_metadata) {
   // Configure max receive size.
-  auto max_recv_message_length = max_recv_size_;
-  const MessageSizeParsedConfig* limits =
-      MessageSizeParsedConfig::GetFromCallContext(
-          GetContext<Arena>(), message_size_service_config_parser_index_);
-  if (limits != nullptr && limits->max_recv_size().has_value() &&
-      (!max_recv_message_length.has_value() ||
-       *limits->max_recv_size() < *max_recv_message_length)) {
-    max_recv_message_length = limits->max_recv_size();
-  }
-  return DecompressArgs{incoming_metadata.get(GrpcEncodingMetadata())
-                            .value_or(GRPC_COMPRESS_NONE),
-                        max_recv_message_length};
+  return DecompressArgs{
+      incoming_metadata.get(GrpcEncodingMetadata())
+          .value_or(GRPC_COMPRESS_NONE),
+      GetMaxRecvSizeFromCallContext(GetContext<Arena>(), max_recv_size_)};
 }
 
 void ClientCompressionFilter::Call::OnClientInitialMetadata(

data/src/core/ext/filters/http/message_compress/compression_filter.h

@@ -107,7 +107,6 @@ class ChannelCompression {
  private:
   // Max receive message length, if set.
   std::optional<uint32_t> max_recv_size_;
-  size_t message_size_service_config_parser_index_;
   // The default, channel-level, compression algorithm.
   grpc_compression_algorithm default_compression_algorithm_;
   // Enabled compression algorithms.

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

@@ -106,6 +106,7 @@
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/telemetry/tcp_tracer.h"
 #include "src/core/transport/auth_context.h"
+#include "src/core/transport/message_size_service_config.h"
 #include "src/core/util/bitset.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
@@ -816,6 +817,7 @@ grpc_chttp2_transport::grpc_chttp2_transport(
           Ref(), &init_keepalive_ping_locked),
       absl::OkStatus());
 
+  // TODO(tjagtap) : [PH2][P0] : Do this for PH2.
   if (flow_control.bdp_probe()) {
     bdp_ping_blocked = true;
     grpc_chttp2_act_on_flowctl_action(flow_control.PeriodicUpdate(), this,
@@ -859,6 +861,9 @@ grpc_chttp2_transport::grpc_chttp2_transport(
       epte->SetSocketNode(channelz_socket);
     }
   }
+
+  max_recv_message_length =
+      grpc_core::GetMaxRecvSizeFromChannelArgs(channel_args);
 }
 
 static void destroy_transport_locked(void* tp, grpc_error_handle /*error*/) {
@@ -879,6 +884,10 @@ static void close_transport_locked(grpc_chttp2_transport* t,
                                    grpc_error_handle error) {
   end_all_the_calls(t, error);
   cancel_pings(t, error);
+  if (t->transport_framing_endpoint_extension != nullptr) {
+    t->transport_framing_endpoint_extension->SetSendFrameCallback(nullptr);
+    t->transport_framing_endpoint_extension = nullptr;
+  }
   if (t->closed_with_error.ok()) {
     if (!grpc_error_has_clear_grpc_status(error)) {
       error =
@@ -1507,7 +1516,8 @@ static grpc_closure* add_closure_barrier(grpc_closure* closure) {
   return closure;
 }
 
-static void null_then_sched_closure(grpc_closure** closure) {
+static void null_then_sched_closure_with_error(grpc_closure** closure,
+                                               grpc_error_handle error) {
   grpc_closure* c = *closure;
   *closure = nullptr;
   // null_then_schedule_closure might be run during a start_batch which might
@@ -1516,7 +1526,11 @@ static void null_then_sched_closure(grpc_closure** closure) {
   // completion, have the application see it, and make a new operation on the
   // call which recycles the batch BEFORE the call to start_batch completes,
   // forcing a race.
-  grpc_core::ExecCtx::Run(DEBUG_LOCATION, c, absl::OkStatus());
+  grpc_core::ExecCtx::Run(DEBUG_LOCATION, c, error);
+}
+
+static void null_then_sched_closure(grpc_closure** closure) {
+  null_then_sched_closure_with_error(closure, absl::OkStatus());
 }
 
 void grpc_chttp2_complete_closure_step(grpc_chttp2_transport* t,
@@ -2343,6 +2357,8 @@ void grpc_chttp2_maybe_complete_recv_initial_metadata(grpc_chttp2_transport* t,
       t->registered_method_matcher_cb(t->accept_stream_cb_user_data,
                                       s->recv_initial_metadata);
     }
+    s->max_recv_message_length =
+        GetMaxRecvSizeFromCallContext(s->arena, t->max_recv_message_length);
     null_then_sched_closure(&s->recv_initial_metadata_ready);
   }
 }
@@ -2415,7 +2431,36 @@ void grpc_chttp2_maybe_complete_recv_message(grpc_chttp2_transport* t,
         *s->call_failed_before_recv_message =
             (s->published_metadata[1] != GRPC_METADATA_PUBLISHED_AT_CLOSE);
       }
-      null_then_sched_closure(&s->recv_message_ready);
+      if (s->seen_error && s->message_size_limit_exceeded) {
+        null_then_sched_closure_with_error(&s->recv_message_ready, error);
+      } else {
+        null_then_sched_closure(&s->recv_message_ready);
+      }
+    } else if (s->seen_error && s->message_size_limit_exceeded) {
+      null_then_sched_closure_with_error(&s->recv_message_ready, error);
+    }
+
+    if (grpc_core::IsMessageSizeRefactoringEnabled() && s->seen_error &&
+        s->message_size_limit_exceeded) {
+      s->message_size_limit_exceeded = false;
+      // Explicitly cancel the stream to fail the RPC immediately.
+      // We delay the cancellation until the recv_message_ready closure is
+      // executed to prevent re-entrancy issues. When the HTTP/2 frame deframer
+      // in `grpc_deframe_unprocessed_incoming_frames`
+      // returns a size violation error, invoking `grpc_chttp2_cancel_stream`
+      // immediately triggers `grpc_chttp2_mark_stream_closed`. This in turn
+      // synchronously re-enters `grpc_chttp2_maybe_complete_recv_message` while
+      // the original deframing loop is still active on the call stack.
+      //
+      // Because the re-entrant invocation observes that the incoming frame
+      // storage has been cleared but `s->recv_message_ready` is still non-null,
+      // it preemptively schedules the closure as a standard/non-error stream
+      // termination (i.e., via `null_then_sched_closure(...,
+      // absl::OkStatus())`). By the time control returns to the initial (outer)
+      // deframing loop to execute `null_then_sched_closure_with_error`, the
+      // closure pointer is already null, causing the original error context to
+      // be discarded.
+      grpc_chttp2_cancel_stream(t, s, error, true, nullptr);
     }
   }();
 

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

@@ -48,6 +48,7 @@ absl::Status grpc_chttp2_data_parser_begin_frame(uint8_t flags,
   } else {
     s->received_last_frame = false;
   }
+  ++s->num_frames;
 
   return absl::OkStatus();
 }
@@ -123,6 +124,24 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
                   (static_cast<uint32_t>(header[3]) << 8) |
                   static_cast<uint32_t>(header[4]);
 
+  if (grpc_core::IsMessageSizeRefactoringEnabled()) {
+    if (s->max_recv_message_length.has_value() &&
+        length > *(s->max_recv_message_length)) {
+      error = GRPC_ERROR_CREATE(
+          absl::StrFormat("%s: Received message larger than max (%d vs. %u)",
+                          s->t->is_client ? "CLIENT" : "SERVER", length,
+                          *(s->max_recv_message_length)));
+      error = grpc_error_set_int(error, grpc_core::StatusIntProperty::kStreamId,
+                                 static_cast<intptr_t>(s->id));
+      // Attach the explicit gRPC status code to fail the RPC correctly.
+      error =
+          grpc_error_set_int(error, grpc_core::StatusIntProperty::kRpcStatus,
+                             GRPC_STATUS_RESOURCE_EXHAUSTED);
+      s->message_size_limit_exceeded = true;
+      return error;
+    }
+  }
+
   if (slices->length < length + GRPC_HEADER_SIZE_IN_BYTES) {
     if (min_progress_size != nullptr) {
       *min_progress_size = length + GRPC_HEADER_SIZE_IN_BYTES - slices->length;
@@ -138,6 +157,7 @@ grpc_core::Poll<grpc_error_handle> grpc_deframe_unprocessed_incoming_frames(
     grpc_slice_buffer_move_first_into_buffer(slices, GRPC_HEADER_SIZE_IN_BYTES,
                                              header);
     grpc_slice_buffer_move_first(slices, length, stream_out->c_slice_buffer());
+    s->num_frames = 0;
   }
 
   return absl::OkStatus();
@@ -148,8 +168,20 @@ grpc_error_handle grpc_chttp2_data_parser_parse(void* /*parser*/,
                                                 grpc_chttp2_stream* s,
                                                 const grpc_slice& slice,
                                                 int is_last) {
-  grpc_core::CSliceRef(slice);
-  grpc_slice_buffer_add(&s->frame_storage, slice);
+  const size_t slice_len = GRPC_SLICE_LENGTH(slice);
+  bool is_small_frame = 0 < slice_len && slice_len < GRPC_SLICE_INLINED_SIZE;
+  bool multiple_small_frames =
+      (s->num_frames >= 64) &&
+      ((s->frame_storage.length / s->num_frames) < GRPC_SLICE_INLINED_SIZE);
+  if (GPR_UNLIKELY(multiple_small_frames && is_small_frame &&
+                   grpc_core::IsHeaderDataFrameEnabled())) {
+    uint8_t* append_ptr =
+        grpc_slice_buffer_tiny_add(&s->frame_storage, slice_len);
+    memcpy(append_ptr, GRPC_SLICE_START_PTR(slice), slice_len);
+  } else {
+    grpc_core::CSliceRef(slice);
+    grpc_slice_buffer_add(&s->frame_storage, slice);
+  }
   grpc_chttp2_maybe_complete_recv_message(t, s);
 
   if (is_last) {

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

@@ -31,11 +31,15 @@
 #include "absl/strings/string_view.h"
 
 void grpc_chttp2_goaway_parser_init(grpc_chttp2_goaway_parser* p) {
-  p->debug_data = nullptr;
+  if (!grpc_core::IsPh2Perf01Enabled()) {
+    p->debug_data = nullptr;
+  }
 }
 
 void grpc_chttp2_goaway_parser_destroy(grpc_chttp2_goaway_parser* p) {
-  gpr_free(p->debug_data);
+  if (!grpc_core::IsPh2Perf01Enabled()) {
+    gpr_free(p->debug_data);
+  }
 }
 
 grpc_error_handle grpc_chttp2_goaway_parser_begin_frame(
@@ -45,10 +49,14 @@ grpc_error_handle grpc_chttp2_goaway_parser_begin_frame(
         absl::StrFormat("goaway frame too short (%d bytes)", length));
   }
 
-  gpr_free(p->debug_data);
   p->debug_length = length - 8;
-  p->debug_data = static_cast<char*>(gpr_malloc(p->debug_length));
-  p->debug_pos = 0;
+  if (grpc_core::IsPh2Perf01Enabled()) {
+    p->debug_slice_buffer.Clear();
+  } else {
+    gpr_free(p->debug_data);
+    p->debug_data = static_cast<char*>(gpr_malloc(p->debug_length));
+    p->debug_pos = 0;
+  }
   p->state = GRPC_CHTTP2_GOAWAY_LSI0;
   return absl::OkStatus();
 }
@@ -130,24 +138,48 @@ grpc_error_handle grpc_chttp2_goaway_parser_parse(void* parser,
       ++cur;
       [[fallthrough]];
     case GRPC_CHTTP2_GOAWAY_DEBUG:
-      if (end != cur) {
-        memcpy(p->debug_data + p->debug_pos, cur,
-               static_cast<size_t>(end - cur));
-      }
-      GRPC_CHECK((size_t)(end - cur) < UINT32_MAX - p->debug_pos);
-      p->debug_pos += static_cast<uint32_t>(end - cur);
-      p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
-      if (is_last) {
-        t->http2_ztrace_collector.Append([p]() {
-          return grpc_core::H2GoAwayTrace<true>{
-              p->last_stream_id, p->error_code,
-              std::string(absl::string_view(p->debug_data, p->debug_length))};
-        });
-        grpc_chttp2_add_incoming_goaway(
-            t, p->error_code, p->last_stream_id,
-            absl::string_view(p->debug_data, p->debug_length));
-        gpr_free(p->debug_data);
-        p->debug_data = nullptr;
+      if (grpc_core::IsPh2Perf01Enabled()) {
+        if (end != cur) {
+          p->debug_slice_buffer.AppendIndexed(
+              grpc_core::Slice::FromCopiedBuffer(
+                  cur, static_cast<size_t>(end - cur)));
+        }
+        GRPC_CHECK(p->debug_slice_buffer.Length() <= p->debug_length);
+        p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
+        if (is_last) {
+          std::string debug_str = p->debug_slice_buffer.JoinIntoString();
+
+          grpc_chttp2_add_incoming_goaway(t, p->error_code, p->last_stream_id,
+                                          absl::string_view(debug_str));
+
+          t->http2_ztrace_collector.Append(
+              [last_stream_id = p->last_stream_id, error_code = p->error_code,
+               debug_str = std::move(debug_str)]() mutable {
+                return grpc_core::H2GoAwayTrace<true>{
+                    last_stream_id, error_code, std::move(debug_str)};
+              });
+          p->debug_slice_buffer.Clear();
+        }
+      } else {
+        if (end != cur) {
+          memcpy(p->debug_data + p->debug_pos, cur,
+                 static_cast<size_t>(end - cur));
+        }
+        GRPC_CHECK((size_t)(end - cur) < UINT32_MAX - p->debug_pos);
+        p->debug_pos += static_cast<uint32_t>(end - cur);
+        p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
+        if (is_last) {
+          t->http2_ztrace_collector.Append([p]() {
+            return grpc_core::H2GoAwayTrace<true>{
+                p->last_stream_id, p->error_code,
+                std::string(absl::string_view(p->debug_data, p->debug_length))};
+          });
+          grpc_chttp2_add_incoming_goaway(
+              t, p->error_code, p->last_stream_id,
+              absl::string_view(p->debug_data, p->debug_length));
+          gpr_free(p->debug_data);
+          p->debug_data = nullptr;
+        }
       }
       return absl::OkStatus();
   }

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

@@ -44,6 +44,7 @@ struct grpc_chttp2_goaway_parser {
   uint32_t last_stream_id;
   uint32_t error_code;
   char* debug_data;
+  grpc_core::SliceBuffer debug_slice_buffer;
   uint32_t debug_length;
   uint32_t debug_pos;
 };

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

@@ -629,6 +629,8 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
 
   GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
 
+  std::optional<uint32_t> max_recv_message_length;
+
   // Current mitigation engine, retrieved once per connection.
   grpc_core::RefCountedPtr<grpc_core::MitigationEngine> mitigation_engine;
 };
@@ -718,6 +720,7 @@ struct grpc_chttp2_stream {
   grpc_metadata_batch trailing_metadata_buffer;
 
   grpc_slice_buffer frame_storage;  // protected by t combiner
+  size_t num_frames = 0;            // protected by t combiner
 
   grpc_core::Timestamp deadline = grpc_core::Timestamp::InfFuture();
 
@@ -777,6 +780,9 @@ struct grpc_chttp2_stream {
   // The last time a stream window update was received.
   grpc_core::Timestamp last_window_update_time =
       grpc_core::Timestamp::InfPast();
+
+  bool message_size_limit_exceeded = false;
+  std::optional<uint32_t> max_recv_message_length;
 };
 
 /// Transport writing call flow:

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

@@ -430,6 +430,14 @@ static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
         t->incoming_frame_type));
   }
   t->is_first_frame = false;
+
+  if (grpc_core::IsPh2Perf01Enabled() &&
+      t->incoming_frame_size > t->settings.acked().max_frame_size()) {
+    return GRPC_ERROR_CREATE(absl::StrFormat(
+        "Frame size %d is larger than max frame size %d",
+        t->incoming_frame_size, t->settings.acked().max_frame_size()));
+  }
+
   if (t->expect_continuation_stream_id != 0) {
     if (t->incoming_frame_type != GRPC_CHTTP2_FRAME_CONTINUATION) {
       return GRPC_ERROR_CREATE(