grpc 1.76.0 → 1.78.0.pre1

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

@@ -18,41 +18,146 @@
 
 #include "src/core/ext/transport/chttp2/transport/http2_transport.h"
 
+#include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
+
+#include <algorithm>
+#include <climits>
 #include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
 #include <utility>
+#include <vector>
 
-#include "src/core/call/call_spine.h"
 #include "src/core/call/metadata_info.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
-#include "src/core/lib/promise/mpsc.h"
-#include "src/core/lib/promise/party.h"
-#include "src/core/lib/transport/promise_endpoint.h"
-#include "src/core/lib/transport/transport.h"
+#include "src/core/ext/transport/chttp2/transport/header_assembler.h"
+#include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings_promises.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/ext/transport/chttp2/transport/internal_channel_arg_names.h"
+#include "src/core/ext/transport/chttp2/transport/stream.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/event_engine/tcp_socket_utils.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
-#include "src/core/util/sync.h"
+#include "src/core/util/time.h"
+#include "absl/log/log.h"
+#include "absl/types/span.h"
 
 namespace grpc_core {
 namespace http2 {
 
+// All Promise Based HTTP2 Transport TODOs have the tag
+// [PH2][Pn] where n = 0 to 5.
+// This helps to maintain the uniformity for quick lookup and fixing.
+//
+// [PH2][P0] MUST be fixed before the current PR is submitted.
+// [PH2][P1] MUST be fixed before the current sub-project is considered
+//           complete.
+// [PH2][P2] MUST be fixed before the current Milestone is considered
+//           complete.
+// [PH2][P3] MUST be fixed before Milestone 3 is considered complete.
+// [PH2][P4] Can be fixed after roll out begins. Evaluate these during
+//           Milestone 4. Either do the TODOs or delete them.
+// [PH2][P5] Can be fixed after roll out begins. Evaluate these during
+//           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.
+
+constexpr Duration kDefaultPingTimeout = Duration::Minutes(1);
+constexpr Duration kDefaultKeepaliveTimeout = Duration::Seconds(20);
+constexpr bool kDefaultKeepalivePermitWithoutCalls = false;
+constexpr bool kDefaultEnablePreferredRxCryptoFrameAdvertisement = false;
+constexpr bool kDefaultAckPings = true;
+
+constexpr Duration kClientKeepaliveTime = Duration::Infinity();
+
+constexpr Duration kServerKeepaliveTime = Duration::Hours(2);
+
 // Experimental : This is just the initial skeleton of class
 // 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.)
 
+///////////////////////////////////////////////////////////////////////////////
+// Settings helpers
+
 void InitLocalSettings(Http2Settings& settings, const bool is_client) {
   if (is_client) {
     // gRPC has never supported PUSH_PROMISE and we have no plan to do so in the
     // future.
     settings.SetEnablePush(false);
-    // This is to make it double-sure that server cannot initite a stream.
+    // This is to make it double-sure that server cannot initiate a stream.
     settings.SetMaxConcurrentStreams(0);
   }
   settings.SetMaxHeaderListSize(DEFAULT_MAX_HEADER_LIST_SIZE);
   settings.SetAllowTrueBinaryMetadata(true);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Channel Args helpers
+void ReadChannelArgs(const ChannelArgs& channel_args,
+                     TransportChannelArgs& args, Http2Settings& local_settings,
+                     chttp2::TransportFlowControl& flow_control,
+                     bool is_client) {
+  ReadSettingsFromChannelArgs(channel_args, local_settings, flow_control,
+                              is_client);
+
+  args.max_header_list_size_soft_limit =
+      GetSoftLimitFromChannelArgs(channel_args);
+  args.keepalive_time = std::max(
+      Duration::Milliseconds(1),
+      channel_args.GetDurationFromIntMillis(GRPC_ARG_KEEPALIVE_TIME_MS)
+          .value_or(is_client ? kClientKeepaliveTime : kServerKeepaliveTime));
+  args.keepalive_timeout = std::max(
+      Duration::Zero(),
+      channel_args.GetDurationFromIntMillis(GRPC_ARG_KEEPALIVE_TIMEOUT_MS)
+          .value_or(args.keepalive_time == Duration::Infinity()
+                        ? Duration::Infinity()
+                        : kDefaultKeepaliveTimeout));
+  args.ping_timeout =
+      std::max(Duration::Zero(),
+               channel_args.GetDurationFromIntMillis(GRPC_ARG_PING_TIMEOUT_MS)
+                   .value_or(args.keepalive_time == Duration::Infinity()
+                                 ? Duration::Infinity()
+                                 : kDefaultPingTimeout));
+  args.settings_timeout =
+      channel_args.GetDurationFromIntMillis(GRPC_ARG_SETTINGS_TIMEOUT)
+          .value_or(std::max(args.keepalive_timeout * 2, Duration::Minutes(1)));
+
+  args.keepalive_permit_without_calls =
+      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);
+
+  args.initial_sequence_number =
+      channel_args.GetInt(GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER).value_or(-1);
+  if (args.initial_sequence_number >= 0 &&
+      (args.initial_sequence_number & 1) == 0) {
+    LOG(ERROR) << "Initial sequence number MUST be odd. Ignoring the value.";
+    args.initial_sequence_number = -1;
+  }
+
+  args.test_only_ack_pings =
+      channel_args.GetBool("grpc.http2.ack_pings").value_or(kDefaultAckPings);
+
+  GRPC_HTTP2_COMMON_DLOG << "ChannelArgs: " << args.DebugString();
+}
+
 void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
                                  Http2Settings& local_settings,
                                  chttp2::TransportFlowControl& flow_control,
@@ -108,6 +213,11 @@ 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()
@@ -124,6 +234,9 @@ void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
       << "}";
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// ChannelZ helpers
+
 RefCountedPtr<channelz::SocketNode> CreateChannelzSocketNode(
     std::shared_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
         event_engine_endpoint,
@@ -145,5 +258,171 @@ RefCountedPtr<channelz::SocketNode> CreateChannelzSocketNode(
   return nullptr;
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// Flow control helpers
+
+void ProcessOutgoingDataFrameFlowControl(
+    chttp2::StreamFlowControl& stream_flow_control,
+    const uint32_t flow_control_tokens_consumed) {
+  if (flow_control_tokens_consumed > 0) {
+    chttp2::StreamFlowControl::OutgoingUpdateContext fc_update(
+        &stream_flow_control);
+    // This updates flow control tokens for both stream and transport flow
+    // control.
+    fc_update.SentData(flow_control_tokens_consumed);
+  }
+}
+
+ValueOrHttp2Status<chttp2::FlowControlAction>
+ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame_header,
+                                    chttp2::TransportFlowControl& flow_control,
+                                    RefCountedPtr<Stream> stream) {
+  GRPC_DCHECK_EQ(frame_header.type, 0u);
+  if (frame_header.length > 0) {
+    if (stream == nullptr) {
+      // This flow control bookkeeping needs to happen even though the stream is
+      // gone because otherwise we will go out-of-sync with the peer.
+      // The flow control numbers should be consistent for both peers.
+      chttp2::TransportFlowControl::IncomingUpdateContext transport_fc(
+          &flow_control);
+      absl::Status fc_status = transport_fc.RecvData(frame_header.length);
+      chttp2::FlowControlAction action = transport_fc.MakeAction();
+      GRPC_HTTP2_COMMON_DLOG
+          << "ProcessIncomingDataFrameFlowControl Transport RecvData status: "
+          << fc_status << " action: " << action.DebugString();
+      if (!fc_status.ok()) {
+        LOG(ERROR) << "Flow control error: " << fc_status.message();
+        // RFC9113 : A receiver MAY respond with a stream error or connection
+        // error of type FLOW_CONTROL_ERROR if it is unable to accept a frame.
+        return Http2Status::Http2ConnectionError(
+            Http2ErrorCode::kFlowControlError,
+            std::string(fc_status.message()));
+      }
+      return action;
+    } else {
+      chttp2::StreamFlowControl::IncomingUpdateContext stream_fc(
+          &stream->flow_control);
+      absl::Status fc_status = stream_fc.RecvData(frame_header.length);
+      chttp2::FlowControlAction action = stream_fc.MakeAction();
+      GRPC_HTTP2_COMMON_DLOG
+          << "ProcessIncomingDataFrameFlowControl Stream RecvData status: "
+          << fc_status << " action: " << action.DebugString();
+      if (!fc_status.ok()) {
+        LOG(ERROR) << "Flow control error: " << fc_status.message();
+        // RFC9113 : A receiver MAY respond with a stream error or connection
+        // error of type FLOW_CONTROL_ERROR if it is unable to accept a frame.
+        return Http2Status::Http2ConnectionError(
+            Http2ErrorCode::kFlowControlError,
+            std::string(fc_status.message()));
+      }
+      // TODO(tjagtap) [PH2][P1][FlowControl] This is a HACK. Fix this.
+      stream_fc.HackIncrementPendingSize(frame_header.length);
+      return action;
+    }
+  }
+  return chttp2::FlowControlAction();
+}
+
+bool ProcessIncomingWindowUpdateFrameFlowControl(
+    const Http2WindowUpdateFrame& frame,
+    chttp2::TransportFlowControl& flow_control, RefCountedPtr<Stream> stream) {
+  if (frame.stream_id != 0) {
+    if (stream != nullptr) {
+      GRPC_HTTP2_COMMON_DLOG
+          << "ProcessIncomingWindowUpdateFrameFlowControl stream "
+          << frame.stream_id << " increment " << frame.increment;
+      chttp2::StreamFlowControl::OutgoingUpdateContext fc_update(
+          &stream->flow_control);
+      fc_update.RecvUpdate(frame.increment);
+    } else {
+      // If stream id is non zero, and stream is nullptr, maybe the stream was
+      // closed. Ignore this WINDOW_UPDATE frame.
+      GRPC_HTTP2_COMMON_DLOG
+          << "ProcessIncomingWindowUpdateFrameFlowControl stream "
+          << frame.stream_id << " not found. Ignoring.";
+    }
+  } else {
+    GRPC_HTTP2_COMMON_DLOG
+        << "ProcessIncomingWindowUpdateFrameFlowControl transport increment "
+        << frame.increment;
+    chttp2::TransportFlowControl::OutgoingUpdateContext fc_update(
+        &flow_control);
+    fc_update.RecvUpdate(frame.increment);
+    if (fc_update.Finish() == chttp2::StallEdge::kUnstalled) {
+      // If transport moves from kStalled to kUnstalled, streams blocked by
+      // transport flow control will become writable. Return true to trigger a
+      // write cycle and attempt to send data from these streams.
+      // Although it's possible no streams were blocked, triggering an
+      // unnecessary write cycle in that super-rare case is acceptable.
+      GRPC_HTTP2_COMMON_DLOG << "ProcessIncomingWindowUpdateFrameFlowControl "
+                                "Transport Unstalled";
+      return true;
+    }
+  }
+  return false;
+}
+
+void MaybeAddStreamWindowUpdateFrame(RefCountedPtr<Stream> stream,
+                                     std::vector<Http2Frame>& frames) {
+  GRPC_HTTP2_COMMON_DLOG << "MaybeAddStreamWindowUpdateFrame stream="
+                         << ((stream == nullptr)
+                                 ? "null"
+                                 : absl::StrCat(
+                                       stream->GetStreamId(),
+                                       " CanSendWindowUpdateFrames=",
+                                       stream->CanSendWindowUpdateFrames()));
+  if (stream != nullptr && stream->CanSendWindowUpdateFrames()) {
+    const uint32_t increment = stream->flow_control.MaybeSendUpdate();
+    GRPC_HTTP2_COMMON_DLOG
+        << "MaybeAddStreamWindowUpdateFrame MaybeSendUpdate { "
+        << stream->GetStreamId() << ", " << increment << " }"
+        << (increment == 0 ? ". The frame will NOT be sent for increment 0"
+                           : "");
+    if (increment > 0) {
+      frames.emplace_back(
+          Http2WindowUpdateFrame{stream->GetStreamId(), increment});
+    }
+  }
+}
+
+// /////////////////////////////////////////////////////////////////////////////
+// Header and Continuation frame processing helpers
+
+Http2Status ParseAndDiscardHeaders(HPackParser& parser, SliceBuffer&& buffer,
+                                   HeaderAssembler::ParseHeaderArgs args,
+                                   const RefCountedPtr<Stream> stream,
+                                   Http2Status&& original_status) {
+  GRPC_HTTP2_COMMON_DLOG << "ParseAndDiscardHeaders buffer "
+                            "size: "
+                         << buffer.Length() << " args: " << args.DebugString()
+                         << " stream_id: "
+                         << (stream == nullptr ? 0 : stream->GetStreamId())
+                         << " original_status: "
+                         << original_status.DebugString();
+
+  if (stream != nullptr) {
+    // Parse all the data in the header assembler
+    Http2Status result = stream->header_assembler.ParseAndDiscardHeaders(
+        parser, args.is_initial_metadata, args.is_client,
+        args.max_header_list_size_soft_limit,
+        args.max_header_list_size_hard_limit);
+    if (!result.IsOk()) {
+      GRPC_DCHECK(result.GetType() ==
+                  Http2Status::Http2ErrorType::kConnectionError);
+      LOG(ERROR) << "Connection Error: " << result;
+      return result;
+    }
+  }
+
+  if (buffer.Length() == 0) {
+    return std::move(original_status);
+  }
+
+  Http2Status status = HeaderAssembler::ParseHeader(
+      parser, std::move(buffer), /*grpc_metadata_batch=*/nullptr, args);
+
+  return (status.IsOk()) ? std::move(original_status) : std::move(status);
+}
+
 }  // namespace http2
 }  // namespace grpc_core

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

@@ -20,21 +20,24 @@
 #define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HTTP2_TRANSPORT_H
 
 #include <cstdint>
-#include <utility>
+#include <string>
 
-#include "src/core/call/call_spine.h"
-#include "src/core/call/metadata_info.h"
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 #include "src/core/ext/transport/chttp2/transport/frame.h"
+#include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
-#include "src/core/lib/event_engine/tcp_socket_utils.h"
-#include "src/core/lib/promise/mpsc.h"
-#include "src/core/lib/promise/party.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings_manager.h"
+#include "src/core/ext/transport/chttp2/transport/http2_settings_promises.h"
+#include "src/core/ext/transport/chttp2/transport/http2_status.h"
+#include "src/core/ext/transport/chttp2/transport/stream.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/promise/poll.h"
 #include "src/core/lib/transport/promise_endpoint.h"
-#include "src/core/lib/transport/transport.h"
 #include "src/core/util/ref_counted_ptr.h"
-#include "src/core/util/sync.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
 
 namespace grpc_core {
 namespace http2 {
@@ -49,34 +52,199 @@ namespace http2 {
 #define GRPC_HTTP2_CLIENT_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
 
+#define GRPC_HTTP2_CLIENT_ERROR_DLOG \
+  LOG_IF(ERROR, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
+
 #define GRPC_HTTP2_COMMON_DLOG \
   DLOG_IF(INFO, GRPC_TRACE_FLAG_ENABLED(http2_ph2_transport))
 
-// TODO(akshitpatel) : [PH2][P4] : Choose appropriate size later.
-constexpr uint32_t kStreamQueueSize = /*1 MB*/ 1024u * 1024u;
 constexpr uint32_t kMaxWriteSize = /*10 MB*/ 10u * 1024u * 1024u;
 
-enum class HttpStreamState : uint8_t {
-  // https://www.rfc-editor.org/rfc/rfc9113.html#name-stream-states
-  kIdle,
-  kOpen,
-  kHalfClosedLocal,
-  kHalfClosedRemote,
-  kClosed,
+constexpr uint32_t kGoawaySendTimeoutSeconds = 5u;
+
+struct CloseStreamArgs {
+  bool close_reads;
+  bool close_writes;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Read and Write helpers
+
+class Http2ReadContext {
+ public:
+  // 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_;
+};
+
+inline PromiseEndpoint::WriteArgs GetWriteArgs(
+    const Http2Settings& peer_settings) {
+  PromiseEndpoint::WriteArgs args;
+  int max_frame_size = peer_settings.preferred_receive_crypto_message_size();
+  // Note: max frame size is 0 if the remote peer does not support adjusting the
+  // sending frame size.
+  if (max_frame_size == 0) {
+    max_frame_size = INT_MAX;
+  }
+  // `WriteArgs.max_frame_size` is a suggestion to the endpoint implementation
+  // to group data to be written into frames of the specified max_frame_size. It
+  // is different from HTTP2 SETTINGS_MAX_FRAME_SIZE. That setting limits HTTP2
+  // frame payload size.
+  args.set_max_frame_size(max_frame_size);
+
+  // TODO(akshitpatel) [PH2][P1] : Currently only the WriteArgs related to
+  // preferred_receive_crypto_message_size have been plumbed. The other write
+  // args may need to be plumbed for PH2.
+  // CHTTP2 : Reference :
+  // File : src/core/ext/transport/chttp2/transport/chttp2_transport.cc
+  // Function : write_action
+
+  return args;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Settings helpers
+
+void InitLocalSettings(Http2Settings& settings, bool is_client);
+
+////////////////////////////////////////////////////////////////////////////////
+// Channel Args helpers
+
+struct TransportChannelArgs {
+  Duration keepalive_time;
+  Duration keepalive_timeout;
+  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;
+  int max_usable_hpack_table_size;
+  int initial_sequence_number;
+
+  std::string DebugString() const {
+    return absl::StrCat(
+        "keepalive_time: ", keepalive_time,
+        " 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,
+        " test_only_ack_pings: ", test_only_ack_pings);
+  }
 };
 
-void InitLocalSettings(Http2Settings& settings, const bool is_client);
+void ReadChannelArgs(const ChannelArgs& channel_args,
+                     TransportChannelArgs& args, Http2Settings& local_settings,
+                     chttp2::TransportFlowControl& flow_control,
+                     bool is_client);
 
 void ReadSettingsFromChannelArgs(const ChannelArgs& channel_args,
                                  Http2Settings& local_settings,
                                  chttp2::TransportFlowControl& flow_control,
-                                 const bool is_client);
+                                 bool is_client);
+
+///////////////////////////////////////////////////////////////////////////////
+// ChannelZ helpers
 
 RefCountedPtr<channelz::SocketNode> CreateChannelzSocketNode(
     std::shared_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
         event_engine_endpoint,
     const ChannelArgs& args);
 
+///////////////////////////////////////////////////////////////////////////////
+// Flow control helpers
+
+void ProcessOutgoingDataFrameFlowControl(
+    chttp2::StreamFlowControl& stream_flow_control,
+    uint32_t flow_control_tokens_consumed);
+
+ValueOrHttp2Status<chttp2::FlowControlAction>
+ProcessIncomingDataFrameFlowControl(Http2FrameHeader& frame,
+                                    chttp2::TransportFlowControl& flow_control,
+                                    RefCountedPtr<Stream> stream);
+
+// Returns true if a write should be triggered
+bool ProcessIncomingWindowUpdateFrameFlowControl(
+    const Http2WindowUpdateFrame& frame,
+    chttp2::TransportFlowControl& flow_control, RefCountedPtr<Stream> stream);
+
+void MaybeAddStreamWindowUpdateFrame(RefCountedPtr<Stream> stream,
+                                     std::vector<Http2Frame>& frames);
+
+///////////////////////////////////////////////////////////////////////////////
+// Header and Continuation frame processing helpers
+
+// This function is used to partially process a HEADER or CONTINUATION frame.
+// `PARTIAL PROCESSING` means reading the payload of a HEADER or CONTINUATION
+// and processing it with the HPACK decoder, and then discarding the payload.
+// This is done to keep the transports HPACK parser in sync with peers HPACK.
+// Scenarios where 'partial processing' is used:
+//
+// Case 1: Received a HEADER/CONTINUATION frame
+// 1. If the frame is invalid ('ParseHeaderFrame'/'ParseContinuationFrame'
+//    returns a non-OK status) then it is a connection error. In this case, we
+//    do NOT invoke 'partial processing' as the transport is about to be closed
+//    anyway.
+// 2. If ParseFramePayload returns a non-OK status, then it is a connection
+//    error. In this case, we do NOT invoke 'partial processing' as the
+//    transport is about to be closed anyway.
+// 3. If the frame is valid, but lookup stream fails, then we invoke 'partial
+//    processing' and pass the current payload through the HPACK decoder. This
+//    can happen if the stream was already closed.
+// 4. If the frame is valid, lookup stream succeeds and we fail while processing
+//    the frame (be it stream or connection error), we first parse the buffered
+//    payload (if any) in the stream through the HPACK decoder and then pass the
+//    current payload through the HPACK decoder.
+// Case 2: Stream close
+// 1. If the stream is being aborted by the upper layers or the transport hit
+//    a stream error on a stream while reading HEADER/CONTINUATION frames, we
+//    invoke 'partial processing' to parse the enqueued buffer (if any) in the
+//    stream to keep our HPACK state consistent with the peer right before
+//    closing the stream. This is done as the next time a HEADER/CONTINUATION
+//    frame is received from the peer, the stream lookup will start failing.
+// This function returns a connection error if HPACK parsing fails. Otherwise,
+// it returns the original status.
+Http2Status ParseAndDiscardHeaders(HPackParser& parser, SliceBuffer&& buffer,
+                                   HeaderAssembler::ParseHeaderArgs args,
+                                   RefCountedPtr<Stream> stream,
+                                   Http2Status&& original_status);
+
 }  // namespace http2
 }  // namespace grpc_core
 

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

@@ -221,6 +221,62 @@ struct H2EndWriteCycle {
   }
 };
 
+struct H2TcpMetricsTrace {
+  std::shared_ptr<
+      grpc_event_engine::experimental::EventEngine::Endpoint::TelemetryInfo>
+      telemetry_info;
+  grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent event;
+  std::vector<
+      grpc_event_engine::experimental::EventEngine::Endpoint::WriteMetric>
+      metrics;
+  absl::Time timestamp;
+
+  size_t MemoryUsage() const {
+    return sizeof(H2TcpMetricsTrace) + metrics.capacity() * sizeof(metrics[0]);
+  }
+
+  channelz::PropertyList ChannelzProperties() const {
+    absl::string_view event_string = "unknown";
+    switch (event) {
+      case grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent::
+          kSendMsg:
+        event_string = "send_msg";
+        break;
+      case grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent::
+          kScheduled:
+        event_string = "scheduled";
+        break;
+      case grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent::
+          kSent:
+        event_string = "sent";
+        break;
+      case grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent::
+          kAcked:
+        event_string = "acked";
+        break;
+      case grpc_event_engine::experimental::EventEngine::Endpoint::WriteEvent::
+          kClosed:
+        event_string = "closed";
+        break;
+      default:
+        break;
+    }
+    return channelz::PropertyList()
+        .Set("event", event_string)
+        .Set("tcp_event_timestamp", timestamp)
+        .Merge([this]() {
+          channelz::PropertyList props;
+          for (const auto& metric : metrics) {
+            if (auto key = telemetry_info->GetMetricName(metric.key);
+                key.has_value()) {
+              props.Set(*key, metric.value);
+            }
+          }
+          return props;
+        }());
+  }
+};
+
 using Http2ZTraceCollector = channelz::ZTraceCollector<
     http2_ztrace_collector_detail::Config, H2DataTrace<false>,
     H2HeaderTrace<false>, H2RstStreamTrace<false>, H2SettingsTrace<false>,
@@ -229,7 +285,7 @@ using Http2ZTraceCollector = channelz::ZTraceCollector<
     H2RstStreamTrace<true>, H2SettingsTrace<true>, H2PingTrace<true>,
     H2GoAwayTrace<true>, H2WindowUpdateTrace<true>, H2SecurityTrace<true>,
     H2UnknownFrameTrace, H2FlowControlStall, H2BeginWriteCycle, H2EndWriteCycle,
-    H2BeginEndpointWrite>;
+    H2BeginEndpointWrite, H2TcpMetricsTrace>;
 
 struct PromiseEndpointReadTrace {
   uint64_t bytes;