grpc 1.81.1 → 1.82.0.pre2

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

@@ -48,6 +48,8 @@ class Http2Settings {
     kGrpcAllowSecurityFrameWireId = 65029,
   };
 
+  constexpr static uint8_t kNumSettings = 9u;
+
   void Diff(bool is_first_send, const Http2Settings& old_setting,
             absl::FunctionRef<void(uint16_t key, uint32_t value)> cb) const;
   GRPC_MUST_USE_RESULT http2::Http2ErrorCode Apply(uint16_t key,
@@ -124,6 +126,23 @@ class Http2Settings {
     return 2147483647u;
   }
 
+  static bool IsKnownSettingId(const uint16_t id) {
+    switch (id) {
+      case kHeaderTableSizeWireId:
+      case kEnablePushWireId:
+      case kMaxConcurrentStreamsWireId:
+      case kInitialWindowSizeWireId:
+      case kMaxFrameSizeWireId:
+      case kMaxHeaderListSizeWireId:
+      case kGrpcAllowTrueBinaryMetadataWireId:
+      case kGrpcPreferredReceiveCryptoFrameSizeWireId:
+      case kGrpcAllowSecurityFrameWireId:
+        return true;
+      default:
+        return false;
+    }
+  }
+
   static std::string WireIdToName(uint16_t wire_id);
 
   bool operator==(const Http2Settings& rhs) const {
@@ -161,8 +180,6 @@ class Http2Settings {
   // We plan to change that in the future.
   uint32_t header_table_size_ = 4096u;
 
-  // TODO(tjagtap) [PH2][P4] : Get the history of why this default was decided
-  // and write it here.
   // CLIENT : Set only once in the lifetime of a client transport. This is set
   // to 0 for client.
   // SERVER : This setting can change for the server. This is usually changed to
@@ -180,8 +197,6 @@ class Http2Settings {
   // handle memory pressure.
   uint32_t max_frame_size_ = 16384u;
 
-  // TODO(tjagtap) [PH2][P4] : Get the history of why this default was decided
-  // and write it here.
   // This is an advisory but we currently enforce it.
   // Set only once in the lifetime of a transport currently.
   // When a peer that updates this more than once, that may indicate either an

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

@@ -32,8 +32,6 @@
 
 namespace grpc_core {
 
-// TODO(tjagtap) [PH2][P1][Settings] : Add new DCHECKs to PH2-Only functions in
-// this class.
 class Http2SettingsManager {
  public:
   // Only local and peer settings can be edited by the transport.

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

@@ -23,6 +23,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <algorithm>
+#include <cstddef>
 #include <cstdint>
 #include <optional>
 #include <string>
@@ -49,6 +50,7 @@
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/time.h"
+#include "absl/container/flat_hash_map.h"
 #include "absl/functional/any_invocable.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
@@ -74,7 +76,9 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   explicit SettingsPromiseManager(
       absl::AnyInvocable<void(absl::StatusOr<uint32_t>)> on_receive_settings)
       : on_receive_first_settings_(std::move(on_receive_settings)),
-        state_(SettingsState::kWaitingForFirstPeerSettings) {}
+        state_(SettingsState::kWaitingForFirstPeerSettings) {
+    pending_peer_settings_.reserve(Http2Settings::kNumSettings + 1);
+  }
 
   ~SettingsPromiseManager() override {
     GRPC_DCHECK(on_receive_first_settings_ == nullptr);
@@ -113,12 +117,19 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // Called when transport receives a SETTINGS ACK frame from peer.
   // This SETTINGS ACK was sent by peer to confirm receipt of SETTINGS frame
   // sent by us. Stop the settings timeout promise.
-  GRPC_MUST_USE_RESULT bool OnSettingsAckReceived() {
+  http2::Http2Status OnSettingsAckReceived() {
     bool is_valid = settings_.AckLastSend();
     if (is_valid) {
       RecordReceivedAck();
+    } else {
+      LOG(ERROR) << "Settings ack received without sending settings.";
+      // CHTTP2 and PH2 return connection error for an unsolicited SETTINGS ACK.
+      // RFC 9113 does not explicitly specify unsolicited ACK handling.
+      return http2::Http2Status::Http2ConnectionError(
+          http2::Http2ErrorCode::kInternalError,
+          std::string(GrpcErrors::kUnsolicitedSettingsAck));
     }
-    return is_valid;
+    return http2::Http2Status::Ok();
   }
 
   // Called when our transport enqueues a SETTINGS frame to send to the peer.
@@ -193,15 +204,24 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // Buffers SETTINGS frames received from peer.
   // Buffered to apply settings at start of next write cycle, only after
   // SETTINGS ACK is written to the endpoint.
-  void BufferPeerSettings(std::vector<Http2SettingsFrame::Setting>&& settings) {
+  http2::Http2Status BufferPeerSettings(
+      std::vector<Http2SettingsFrame::Setting>&& settings) {
+    http2::Http2Status status = ValidateSettingsValues(settings);
+    if (!status.IsOk()) {
+      return status;
+    }
     if (state_ == SettingsState::kWaitingForFirstPeerSettings) {
       state_ = SettingsState::kFirstPeerSettingsReceived;
     }
     ++num_acks_to_send_;
-    pending_peer_settings_.reserve(pending_peer_settings_.size() +
-                                   settings.size());
-    pending_peer_settings_.insert(pending_peer_settings_.end(),
-                                  settings.begin(), settings.end());
+    for (const auto& setting : settings) {
+      // RFC9113: An endpoint that receives a SETTINGS frame with any unknown or
+      // unsupported identifier MUST ignore that setting.
+      if (Http2Settings::IsKnownSettingId(setting.id)) {
+        pending_peer_settings_[setting.id] = setting.value;
+      }
+    }
+    return http2::Http2Status::Ok();
   }
 
   // Applies settings buffered by BufferPeerSettings().
@@ -211,13 +231,20 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   http2::Http2ErrorCode MaybeReportAndApplyBufferedPeerSettings(
       grpc_event_engine::experimental::EventEngine* event_engine,
       bool& should_spawn_security_frame_loop) {
-    http2::Http2ErrorCode status = settings_.ApplyIncomingSettings(
-        std::exchange(pending_peer_settings_, {}));
+    std::vector<Http2SettingsFrame::Setting> settings_to_apply;
+    settings_to_apply.reserve(pending_peer_settings_.size());
+    for (const auto& [id, value] : pending_peer_settings_) {
+      settings_to_apply.emplace_back(id, value);
+    }
+    pending_peer_settings_.clear();
+    http2::Http2ErrorCode status =
+        settings_.ApplyIncomingSettings(settings_to_apply);
     if (state_ == SettingsState::kFirstPeerSettingsReceived) {
       MaybeReportInitialSettings(event_engine);
       state_ = SettingsState::kReady;
       should_spawn_security_frame_loop = IsSecurityFrameExpected();
     }
+    GRPC_DCHECK(pending_peer_settings_.empty());
     return status;
   }
 
@@ -269,11 +296,11 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
     return settings_.ChannelzProperties().SetColumn(
         "Counters",
         channelz::PropertyList().Set("initial_window_size_increase_count",
-                                     initial_window_size_increase_count_));
+                                     num_peer_initial_window_size_increases_));
   }
 
   void IncrementInitialWindowSizeIncreaseCount() {
-    ++initial_window_size_increase_count_;
+    ++num_peer_initial_window_size_increases_;
   }
 
   bool IsSecurityFrameExpected() const {
@@ -281,8 +308,11 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
         << "Security frame must not be received before SETTINGS frame";
     // TODO(tjagtap) : [PH2][P3] : Evaluate when to accept the frame and when to
     // reject it. Compare it with the requirement and with CHTTP2.
-    return (settings_.local().allow_security_frame()) &&
-           settings_.peer().allow_security_frame();
+    const bool is_expected = (settings_.local().allow_security_frame()) &&
+                             settings_.peer().allow_security_frame();
+    GRPC_SETTINGS_TIMEOUT_DLOG
+        << "SettingsPromiseManager::IsSecurityFrameExpected: " << is_expected;
+    return is_expected;
   };
 
  private:
@@ -419,7 +449,7 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   // Data Members for SETTINGS being received from the peer.
 
   absl::AnyInvocable<void(absl::StatusOr<uint32_t>)> on_receive_first_settings_;
-  std::vector<Http2SettingsFrame::Setting> pending_peer_settings_;
+  absl::flat_hash_map<uint16_t, uint32_t> pending_peer_settings_;
   // Number of incoming SETTINGS frames that we have received but not ACKed yet.
   uint32_t num_acks_to_send_ = 0;
 
@@ -430,8 +460,11 @@ class SettingsPromiseManager final : public RefCounted<SettingsPromiseManager> {
   };
   SettingsState state_;
 
-  // Counters
-  size_t initial_window_size_increase_count_ = 0;
+  // Number of times the peer has increased the initial window size. Currently,
+  // PH2 handles this by iterating over all the active streams to potentially
+  // make them writable. This is tracked via channelz in case it causes any
+  // performance issues in the future.
+  size_t num_peer_initial_window_size_increases_ = 0;
 };
 
 }  // namespace grpc_core

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

@@ -72,6 +72,7 @@ namespace http2 {
 //           Milestone 4. Either do the TODOs or delete them.
 // [PH2][EXT] This is a TODO related to a project unrelated to PH2 but happening
 //            in parallel.
+// [PH2][CHTTP2] This TODO is a part of CHTTP2 deletion.
 
 constexpr Duration kDefaultPingTimeout = Duration::Minutes(1);
 constexpr Duration kDefaultKeepaliveTimeout = Duration::Seconds(20);
@@ -132,8 +133,6 @@ std::string TransportChannelArgs::DebugString() const {
       " keepalive_timeout: ", keepalive_timeout,
       " ping_timeout: ", ping_timeout, " settings_timeout: ", settings_timeout,
       " keepalive_permit_without_calls: ", keepalive_permit_without_calls,
-      " enable_preferred_rx_crypto_frame_advertisement: ",
-      enable_preferred_rx_crypto_frame_advertisement,
       " max_header_list_size_soft_limit: ", max_header_list_size_soft_limit,
       " max_usable_hpack_table_size: ", max_usable_hpack_table_size,
       " initial_sequence_number: ", initial_sequence_number,
@@ -173,11 +172,6 @@ void ReadChannelArgs(const ChannelArgs& channel_args,
       channel_args.GetBool(GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS)
           .value_or(kDefaultKeepalivePermitWithoutCalls);
 
-  args.enable_preferred_rx_crypto_frame_advertisement =
-      channel_args
-          .GetBool(GRPC_ARG_EXPERIMENTAL_HTTP2_PREFERRED_CRYPTO_FRAME_SIZE)
-          .value_or(kDefaultEnablePreferredRxCryptoFrameAdvertisement);
-
   args.max_usable_hpack_table_size =
       channel_args.GetInt(GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER).value_or(-1);
 
@@ -235,9 +229,12 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
         channel_args.GetInt(GRPC_ARG_HTTP2_MAX_FRAME_SIZE).value_or(-1));
   }
 
-  if (channel_args
+  const bool enable_preferred_crypto =
+      channel_args
           .GetBool(GRPC_ARG_EXPERIMENTAL_HTTP2_PREFERRED_CRYPTO_FRAME_SIZE)
-          .value_or(false)) {
+          .value_or(kDefaultEnablePreferredRxCryptoFrameAdvertisement);
+  flow_control.set_ph2_enable_rx_crypto(enable_preferred_crypto);
+  if (enable_preferred_crypto) {
     local_settings.SetPreferredReceiveCryptoMessageSize(INT_MAX);
   }
 
@@ -250,11 +247,6 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
   local_settings.SetAllowSecurityFrame(
       channel_args.GetBool(GRPC_ARG_SECURITY_FRAME_ALLOWED).value_or(false));
 
-  // TODO(tjagtap) : [PH2][P4] : If max_header_list_size is set only once
-  // in the life of a transport, consider making this a data member of
-  // class IncomingMetadataTracker instead of accessing via acked settings again
-  // and again. Else delete this comment.
-
   GRPC_HTTP2_COMMON_DLOG
       << "Http2Settings: {"
       << "header_table_size: " << local_settings.header_table_size()
@@ -271,6 +263,12 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
       << "}";
 }
 
+uint32_t MaxNewStreamsPerRead(const ChannelArgs& channel_args) {
+  return Clamp(
+      channel_args.GetInt("grpc.http2.max_requests_per_read").value_or(32), 1,
+      10000);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ChannelZ helpers
 
@@ -311,7 +309,7 @@ void ProcessOutgoingDataFrameFlowControl(
 }
 
 ValueOrHttp2Status<chttp2::FlowControlAction>
-ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame_header,
+ProcessIncomingDataFrameFlowControl(const Http2FrameHeader& frame_header,
                                     chttp2::TransportFlowControl& flow_control,
                                     Stream* stream) {
   GRPC_DCHECK_EQ(frame_header.type, 0u);

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

@@ -45,8 +45,8 @@ namespace http2 {
 // and it is functions. The code will be written iteratively.
 // Do not use or edit any of these functions unless you are
 // familiar with the PH2 project (Moving chttp2 to promises.)
-// TODO(tjagtap) : [PH2][P3] : Update the experimental status of the code before
-// http2 rollout begins.
+// TODO(tjagtap) : [PH2][P3] : Update the experimental status of the code when
+// CHTTP2 is deleted.
 
 #define GRPC_HTTP2_CLIENT_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
@@ -67,6 +67,14 @@ struct CloseStreamArgs {
   bool close_writes;
 };
 
+inline bool ShouldEnablePh2Client() {
+  return IsPh2ClientEnabled() || IsPh2ClientServerEnabled();
+}
+
+inline bool ShouldEnablePh2Server() {
+  return IsPh2ServerEnabled() || IsPh2ClientServerEnabled();
+}
+
 // TODO(akshitpatel) [PH2][P3] : Write a way to measure the total size of a
 // transport object. Reference :
 // https://github.com/grpc/grpc/pull/41294/files#diff-c685cc4847f228327938326e2a45083a2d0845bacff0ac004bd802027a670c4e
@@ -74,48 +82,7 @@ struct CloseStreamArgs {
 ///////////////////////////////////////////////////////////////////////////////
 // Read and Write helpers
 
-class Http2ReadContext {
- public:
-  Http2ReadContext() = default;
-  Http2ReadContext(const Http2ReadContext&) = delete;
-  Http2ReadContext& operator=(const Http2ReadContext&) = delete;
-  Http2ReadContext(Http2ReadContext&&) = delete;
-  Http2ReadContext& operator=(Http2ReadContext&&) = delete;
-
-  // Signals that the read loop should pause. If it's already paused, this is a
-  // no-op.
-  void SetPauseReadLoop() {
-    // TODO(tjagtap) [PH2][P2][Settings] Plumb with when we receive urgent
-    // settings. Example - initial window size 0 is urgent because it indicates
-    // extreme memory pressure on the server.
-    should_pause_read_loop_ = true;
-  }
-
-  // If SetPauseReadLoop() was called, this returns Pending and
-  // registers a waker that will be woken by WakeReadLoop().
-  // If SetPauseReadLoop() was not called, this returns OkStatus.
-  // This should be polled by the read loop to yield control when requested.
-  Poll<absl::Status> MaybePauseReadLoop() {
-    if (should_pause_read_loop_) {
-      read_loop_waker_ = GetContext<Activity>()->MakeNonOwningWaker();
-      return Pending{};
-    }
-    return absl::OkStatus();
-  }
-
-  // If SetPauseReadLoop() was called, resumes it by
-  // waking up the ReadLoop. If not paused, this is a no-op.
-  void ResumeReadLoopIfPaused() {
-    if (should_pause_read_loop_) {
-      should_pause_read_loop_ = false;
-      read_loop_waker_.Wakeup();
-    }
-  }
-
- private:
-  bool should_pause_read_loop_ = false;
-  Waker read_loop_waker_;
-};
+constexpr uint32_t kMaxFramesReadPerReadCycle = 16u * 1024u;  // 16K frames
 
 Http2Status ValidateIncomingConnectionPreface(
     const absl::StatusOr<Slice>& status);
@@ -126,7 +93,7 @@ inline Http2Status ValidateMetadataFrameState(
     const uint32_t max_header_list_size) {
   if (stream.IsStreamHalfClosedRemote()) {
     return incoming_headers.ParseAndDiscardHeaders(
-        std::move(frame.payload), frame.end_headers, &stream,
+        std::move(frame.payload), frame.end_headers,
         Http2Status::Http2StreamError(
             Http2ErrorCode::kStreamClosed,
             std::string(RFC9113::kHalfClosedRemoteState)),
@@ -138,7 +105,7 @@ inline Http2Status ValidateMetadataFrameState(
             stream.IsInitialMetadataReceived(),
             stream.IsTrailingMetadataReceived())) {
       return incoming_headers.ParseAndDiscardHeaders(
-          std::move(frame.payload), frame.end_headers, &stream,
+          std::move(frame.payload), frame.end_headers,
           Http2Status::Http2StreamError(
               Http2ErrorCode::kInternalError,
               std::string(GrpcErrors::kTooManyMetadata)),
@@ -163,7 +130,6 @@ struct TransportChannelArgs {
   Duration ping_timeout;
   Duration settings_timeout;
   bool keepalive_permit_without_calls;
-  bool enable_preferred_rx_crypto_frame_advertisement;
   // This is used to test peer behaviour when we never send a ping ack.
   bool test_only_ack_pings;
   uint32_t max_header_list_size_soft_limit;
@@ -183,6 +149,8 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
                                  chttp2::TransportFlowControl& flow_control,
                                  bool is_client);
 
+uint32_t MaxNewStreamsPerRead(const ChannelArgs& channel_args);
+
 ///////////////////////////////////////////////////////////////////////////////
 // ChannelZ helpers
 
@@ -199,7 +167,7 @@ void ProcessOutgoingDataFrameFlowControl(
     uint32_t flow_control_tokens_consumed);
 
 ValueOrHttp2Status<chttp2::FlowControlAction>
-ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame,
+ProcessIncomingDataFrameFlowControl(const Http2FrameHeader& frame,
                                     chttp2::TransportFlowControl& flow_control,
                                     Stream* stream);
 

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

@@ -72,6 +72,7 @@
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/lib/transport/transport_framing_endpoint_extension.h"
+#include "src/core/mitigation_engine/mitigation_engine.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/telemetry/context_list_entry.h"
 #include "src/core/telemetry/stats.h"
@@ -230,6 +231,9 @@ typedef enum {
   GRPC_CHTTP2_KEEPALIVE_STATE_DISABLED,
 } grpc_chttp2_keepalive_state;
 
+constexpr uint16_t kMaxNoopDataFrames = 16384u;
+constexpr uint16_t kMaxNoopContinuationFrames = 128u;
+
 struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
                                      public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
@@ -472,6 +476,8 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   uint8_t incoming_frame_flags = 0;
   uint8_t header_eof = 0;
   bool is_first_frame = true;
+  uint16_t noop_continuation_frames = 0u;
+  uint16_t noop_data_frames = 0u;
   uint32_t expect_continuation_stream_id = 0;
   uint32_t incoming_frame_size = 0;
 
@@ -618,6 +624,9 @@ struct grpc_chttp2_transport final : public grpc_core::FilterStackTransport,
   grpc_core::Timestamp last_ztrace_time = grpc_core::Timestamp::InfPast();
 
   GPR_NO_UNIQUE_ADDRESS grpc_core::latent_see::Flow write_flow;
+
+  // Current mitigation engine, retrieved once per connection.
+  grpc_core::RefCountedPtr<grpc_core::MitigationEngine> mitigation_engine;
 };
 
 typedef enum {
@@ -878,6 +887,11 @@ void grpc_chttp2_stream_unref(grpc_chttp2_stream* s);
 #endif
 
 void grpc_chttp2_ack_ping(grpc_chttp2_transport* t, uint64_t id);
+grpc_error_handle grpc_chttp2_increase_num_pending_induced_frames(
+    grpc_chttp2_transport* t);
+
+void grpc_chttp2_close_transport_locked(grpc_chttp2_transport* t,
+                                        grpc_error_handle error);
 
 /// Sends GOAWAY with error code ENHANCE_YOUR_CALM and additional debug data
 /// resembling "too_many_pings" followed by immediately closing the connection.

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

@@ -39,7 +39,7 @@ namespace http2 {
 
 #define GRPC_MESSAGE_ASSEMBLER_DEBUG VLOG(2)
 
-// TODO(tjagtap) TODO(akshitpatel): [PH2][P3] : Write micro benchmarks for
+// TODO(akshitpatel): [PH2][P4] : Write micro benchmarks for
 // assembler and disassembler code
 
 constexpr uint32_t kOneGb = (1024u * 1024u * 1024u);
@@ -81,7 +81,6 @@ class GrpcMessageAssembler {
   ValueOrHttp2Status<MessageHandle> ExtractMessage() {
     const size_t current_len = message_buffer_.Length();
     if (current_len < kGrpcHeaderSizeInBytes) {
-      // TODO(tjagtap) : [PH2][P3] : Write a test for this.
       return ReturnNullOrError();
     }
     ValueOrHttp2Status<GrpcMessageHeader> header =