grpc 1.59.5 → 1.60.0.pre1

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

@@ -31,6 +31,8 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/surface/validate_metadata.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
@@ -128,10 +130,18 @@ class HpackParseResult {
  public:
   HpackParseResult() : HpackParseResult{HpackParseStatus::kOk} {}
 
-  bool ok() const { return status_.get() == HpackParseStatus::kOk; }
-  bool stream_error() const { return IsStreamError(status_.get()); }
-  bool connection_error() const { return IsConnectionError(status_.get()); }
-  bool ephemeral() const { return IsEphemeralError(status_.get()); }
+  bool ok() const {
+    return state_ == nullptr || state_->status.get() == HpackParseStatus::kOk;
+  }
+  bool stream_error() const {
+    return state_ != nullptr && IsStreamError(state_->status.get());
+  }
+  bool connection_error() const {
+    return state_ != nullptr && IsConnectionError(state_->status.get());
+  }
+  bool ephemeral() const {
+    return state_ != nullptr && IsEphemeralError(state_->status.get());
+  }
 
   std::unique_ptr<HpackParseResult> PersistentStreamErrorOrNullptr() const {
     if (ok() || connection_error() || ephemeral()) return nullptr;
@@ -154,20 +164,22 @@ class HpackParseResult {
   static HpackParseResult FromStatusWithKey(HpackParseStatus status,
                                             absl::string_view key) {
     auto r = FromStatus(status);
-    r.key_ = std::string(key);
+    if (r.state_ != nullptr) {
+      r.state_->key = std::string(key);
+    }
     return r;
   }
 
   static HpackParseResult MetadataParseError(absl::string_view key) {
     HpackParseResult r{HpackParseStatus::kMetadataParseError};
-    r.key_ = std::string(key);
+    r.state_->key = std::string(key);
     return r;
   }
 
   static HpackParseResult AddBeforeTableSizeUpdated(uint32_t current_size,
                                                     uint32_t max_size) {
     HpackParseResult p{HpackParseStatus::kAddBeforeTableSizeUpdated};
-    p.illegal_table_size_change_ =
+    p.state_->illegal_table_size_change =
         IllegalTableSizeChange{current_size, max_size};
     return p;
   }
@@ -184,8 +196,8 @@ class HpackParseResult {
                                                absl::string_view key) {
     GPR_DEBUG_ASSERT(result != ValidateMetadataResult::kOk);
     HpackParseResult p{HpackParseStatus::kInvalidMetadata};
-    p.key_ = std::string(key);
-    p.validate_metadata_result_ = result;
+    p.state_->key = std::string(key);
+    p.state_->validate_metadata_result = result;
     return p;
   }
 
@@ -196,20 +208,21 @@ class HpackParseResult {
   static HpackParseResult VarintOutOfRangeError(uint32_t value,
                                                 uint8_t last_byte) {
     HpackParseResult p{HpackParseStatus::kVarintOutOfRange};
-    p.varint_out_of_range_ = VarintOutOfRange{last_byte, value};
+    p.state_->varint_out_of_range = VarintOutOfRange{last_byte, value};
     return p;
   }
 
   static HpackParseResult InvalidHpackIndexError(uint32_t index) {
     HpackParseResult p{HpackParseStatus::kInvalidHpackIndex};
-    p.invalid_hpack_index_ = index;
+    p.state_->invalid_hpack_index = index;
     return p;
   }
 
   static HpackParseResult IllegalTableSizeChangeError(uint32_t new_size,
                                                       uint32_t max_size) {
     HpackParseResult p{HpackParseStatus::kIllegalTableSizeChange};
-    p.illegal_table_size_change_ = IllegalTableSizeChange{new_size, max_size};
+    p.state_->illegal_table_size_change =
+        IllegalTableSizeChange{new_size, max_size};
     return p;
   }
 
@@ -220,7 +233,7 @@ class HpackParseResult {
   static HpackParseResult SoftMetadataLimitExceededError(
       grpc_metadata_batch* metadata, uint32_t frame_length, uint32_t limit) {
     HpackParseResult p{HpackParseStatus::kSoftMetadataLimitExceeded};
-    p.metadata_limit_exceeded_ =
+    p.state_->metadata_limit_exceeded =
         MetadataLimitExceeded{frame_length, limit, metadata};
     return p;
   }
@@ -228,7 +241,7 @@ class HpackParseResult {
   static HpackParseResult HardMetadataLimitExceededError(
       grpc_metadata_batch* metadata, uint32_t frame_length, uint32_t limit) {
     HpackParseResult p{HpackParseStatus::kHardMetadataLimitExceeded};
-    p.metadata_limit_exceeded_ =
+    p.state_->metadata_limit_exceeded =
         MetadataLimitExceeded{frame_length, limit, metadata};
     return p;
   }
@@ -236,7 +249,7 @@ class HpackParseResult {
   static HpackParseResult HardMetadataLimitExceededByKeyError(
       uint32_t key_length, uint32_t limit) {
     HpackParseResult p{HpackParseStatus::kHardMetadataLimitExceededByKey};
-    p.metadata_limit_exceeded_by_atom_ =
+    p.state_->metadata_limit_exceeded_by_atom =
         MetadataLimitExceededByAtom{key_length, limit};
     return p;
   }
@@ -244,9 +257,9 @@ class HpackParseResult {
   static HpackParseResult HardMetadataLimitExceededByValueError(
       absl::string_view key, uint32_t value_length, uint32_t limit) {
     HpackParseResult p{HpackParseStatus::kHardMetadataLimitExceededByValue};
-    p.metadata_limit_exceeded_by_atom_ =
+    p.state_->metadata_limit_exceeded_by_atom =
         MetadataLimitExceededByAtom{value_length, limit};
-    p.key_ = std::string(key);
+    p.state_->key = std::string(key);
     return p;
   }
 
@@ -255,7 +268,13 @@ class HpackParseResult {
   absl::Status Materialize() const;
 
  private:
-  explicit HpackParseResult(HpackParseStatus status) : status_(status) {}
+  explicit HpackParseResult(HpackParseStatus status) {
+    // Dynamically allocate state if status is not ok.
+    if (status != HpackParseStatus::kOk) {
+      state_ = MakeRefCounted<HpackParseResultState>(status);
+    }
+  }
+
   absl::Status BuildMaterialized() const;
 
   struct VarintOutOfRange {
@@ -300,25 +319,31 @@ class HpackParseResult {
     HpackParseStatus status_;
   };
 
-  StatusWrapper status_;
-  union {
-    // Set if status == kInvalidMetadata
-    ValidateMetadataResult validate_metadata_result_;
-    // Set if status == kVarintOutOfRange
-    VarintOutOfRange varint_out_of_range_;
-    // Set if status == kInvalidHpackIndex
-    uint32_t invalid_hpack_index_;
-    // Set if status == kHardMetadataLimitExceeded or
-    // kSoftMetadataLimitExceeded
-    MetadataLimitExceeded metadata_limit_exceeded_;
-    // Set if status == kHardMetadataLimitExceededByKey or
-    // kHardMetadataLimitExceededByValue
-    MetadataLimitExceededByAtom metadata_limit_exceeded_by_atom_;
-    // Set if status == kIllegalTableSizeChange
-    IllegalTableSizeChange illegal_table_size_change_;
+  struct HpackParseResultState : public RefCounted<HpackParseResultState> {
+    explicit HpackParseResultState(HpackParseStatus incoming_status)
+        : status(incoming_status) {}
+    StatusWrapper status;
+    union {
+      // Set if status == kInvalidMetadata
+      ValidateMetadataResult validate_metadata_result;
+      // Set if status == kVarintOutOfRange
+      VarintOutOfRange varint_out_of_range;
+      // Set if status == kInvalidHpackIndex
+      uint32_t invalid_hpack_index;
+      // Set if status == kHardMetadataLimitExceeded or
+      // kSoftMetadataLimitExceeded
+      MetadataLimitExceeded metadata_limit_exceeded;
+      // Set if status == kHardMetadataLimitExceededByKey or
+      // kHardMetadataLimitExceededByValue
+      MetadataLimitExceededByAtom metadata_limit_exceeded_by_atom;
+      // Set if status == kIllegalTableSizeChange
+      IllegalTableSizeChange illegal_table_size_change;
+    };
+    std::string key;
+    mutable absl::optional<absl::Status> materialized_status;
   };
-  std::string key_;
-  mutable absl::optional<absl::Status> materialized_status_;
+
+  RefCountedPtr<HpackParseResultState> state_ = nullptr;
 };
 
 }  // namespace grpc_core

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

@@ -91,14 +91,12 @@ constexpr Base64InverseTable kBase64InverseTable;
 class HPackParser::Input {
  public:
   Input(grpc_slice_refcount* current_slice_refcount, const uint8_t* begin,
-        const uint8_t* end, absl::BitGenRef bitsrc,
-        HpackParseResult& frame_error, HpackParseResult& field_error)
+        const uint8_t* end, absl::BitGenRef bitsrc, HpackParseResult& error)
       : current_slice_refcount_(current_slice_refcount),
         begin_(begin),
         end_(end),
         frontier_(begin),
-        frame_error_(frame_error),
-        field_error_(field_error),
+        error_(error),
         bitsrc_(bitsrc) {}
 
   // If input is backed by a slice, retrieve its refcount. If not, return
@@ -217,18 +215,14 @@ class HPackParser::Input {
 
   // Check if we saw an EOF
   bool eof_error() const {
-    return min_progress_size_ != 0 || frame_error_.connection_error();
-  }
-
-  // Reset the field error to be ok
-  void ClearFieldError() {
-    if (field_error_.ok()) return;
-    field_error_ = HpackParseResult();
+    return min_progress_size_ != 0 || error_.connection_error();
   }
 
   // Minimum number of bytes to unstuck the current parse
   size_t min_progress_size() const { return min_progress_size_; }
 
+  bool has_error() const { return !error_.ok(); }
+
   // Set the current error - tweaks the error to include a stream id so that
   // chttp2 does not close the connection.
   // Intended for errors that are specific to a stream and recoverable.
@@ -252,7 +246,10 @@ class HPackParser::Input {
   // read prior to being able to get further in this parse.
   void UnexpectedEOF(size_t min_progress_size) {
     GPR_ASSERT(min_progress_size > 0);
-    if (eof_error()) return;
+    if (min_progress_size_ != 0 || error_.connection_error()) {
+      GPR_DEBUG_ASSERT(eof_error());
+      return;
+    }
     // Set min progress size, taking into account bytes parsed already but not
     // consumed.
     min_progress_size_ = min_progress_size + (begin_ - frontier_);
@@ -305,18 +302,13 @@ class HPackParser::Input {
   // Do not use this directly, instead use SetErrorAndContinueParsing or
   // SetErrorAndStopParsing.
   void SetError(HpackParseResult error) {
-    SetErrorFor(frame_error_, error);
-    SetErrorFor(field_error_, std::move(error));
-  }
-
-  void SetErrorFor(HpackParseResult& error, HpackParseResult new_error) {
-    if (!error.ok() || min_progress_size_ > 0) {
-      if (new_error.connection_error() && !error.connection_error()) {
-        error = std::move(new_error);  // connection errors dominate
+    if (!error_.ok() || min_progress_size_ > 0) {
+      if (error.connection_error() && !error_.connection_error()) {
+        error_ = std::move(error);  // connection errors dominate
       }
       return;
     }
-    error = std::move(new_error);
+    error_ = std::move(error);
   }
 
   // Refcount if we are backed by a slice
@@ -328,8 +320,7 @@ class HPackParser::Input {
   // Frontier denotes the first byte past successfully processed input
   const uint8_t* frontier_;
   // Current error
-  HpackParseResult& frame_error_;
-  HpackParseResult& field_error_;
+  HpackParseResult& error_;
   // If the error was EOF, we flag it here by noting how many more bytes would
   // be needed to make progress
   size_t min_progress_size_ = 0;
@@ -606,7 +597,6 @@ class HPackParser::Parser {
   bool ParseTop() {
     GPR_DEBUG_ASSERT(state_.parse_state == ParseState::kTop);
     auto cur = *input_->Next();
-    input_->ClearFieldError();
     switch (cur >> 4) {
         // Literal header not indexed - First byte format: 0000xxxx
         // Literal header never indexed - First byte format: 0001xxxx
@@ -712,7 +702,7 @@ class HPackParser::Parser {
         break;
     }
     gpr_log(
-        GPR_INFO, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
+        GPR_DEBUG, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
         log_info_.is_client ? "CLI" : "SVR", memento.md.DebugString().c_str(),
         memento.parse_status == nullptr
             ? ""
@@ -961,10 +951,11 @@ class HPackParser::Parser {
                                   state_.string_length)
             : String::Parse(input_, state_.is_string_huff_compressed,
                             state_.string_length);
+    HpackParseResult& status = state_.frame_error;
     absl::string_view key_string;
     if (auto* s = absl::get_if<Slice>(&state_.key)) {
       key_string = s->as_string_view();
-      if (state_.field_error.ok()) {
+      if (status.ok()) {
         auto r = ValidateKey(key_string);
         if (r != ValidateMetadataResult::kOk) {
           input_->SetErrorAndContinueParsing(
@@ -974,7 +965,7 @@ class HPackParser::Parser {
     } else {
       const auto* memento = absl::get<const HPackTable::Memento*>(state_.key);
       key_string = memento->md.key();
-      if (state_.field_error.ok() && memento->parse_status != nullptr) {
+      if (status.ok() && memento->parse_status != nullptr) {
         input_->SetErrorAndContinueParsing(*memento->parse_status);
       }
     }
@@ -1001,16 +992,16 @@ class HPackParser::Parser {
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     auto md = grpc_metadata_batch::Parse(
         key_string, std::move(value_slice), state_.add_to_table, transport_size,
-        [key_string, this](absl::string_view message, const Slice&) {
-          if (!state_.field_error.ok()) return;
+        [key_string, &status, this](absl::string_view message, const Slice&) {
+          if (!status.ok()) return;
           input_->SetErrorAndContinueParsing(
               HpackParseResult::MetadataParseError(key_string));
           gpr_log(GPR_ERROR, "Error parsing '%s' metadata: %s",
                   std::string(key_string).c_str(),
                   std::string(message).c_str());
         });
-    HPackTable::Memento memento{
-        std::move(md), state_.field_error.PersistentStreamErrorOrNullptr()};
+    HPackTable::Memento memento{std::move(md),
+                                status.PersistentStreamErrorOrNullptr()};
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kTop;
     if (state_.add_to_table) {
@@ -1172,13 +1163,13 @@ grpc_error_handle HPackParser::Parse(
     std::vector<uint8_t> buffer = std::move(unparsed_bytes_);
     return ParseInput(
         Input(nullptr, buffer.data(), buffer.data() + buffer.size(), bitsrc,
-              state_.frame_error, state_.field_error),
+              state_.frame_error),
         is_last, call_tracer);
   }
-  return ParseInput(Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
-                          GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error,
-                          state_.field_error),
-                    is_last, call_tracer);
+  return ParseInput(
+      Input(slice.refcount, GRPC_SLICE_START_PTR(slice),
+            GRPC_SLICE_END_PTR(slice), bitsrc, state_.frame_error),
+      is_last, call_tracer);
 }
 
 grpc_error_handle HPackParser::ParseInput(

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

@@ -236,16 +236,10 @@ class HPackParser {
     HPackTable hpack_table;
     // Error so far for this frame (set by class Input)
     HpackParseResult frame_error;
-    // Error so far for this field (set by class Input)
-    HpackParseResult field_error;
     // Length of frame so far.
     uint32_t frame_length = 0;
     // Length of the string being parsed
     uint32_t string_length;
-    // How many more dynamic table updates are allowed
-    uint8_t dynamic_table_updates_allowed;
-    // Current parse state
-    ParseState parse_state = ParseState::kTop;
     // RED for overly large metadata sets
     RandomEarlyDetection metadata_early_detection;
     // Should the current header be added to the hpack table?
@@ -254,6 +248,10 @@ class HPackParser {
     bool is_string_huff_compressed;
     // Is the value being parsed binary?
     bool is_binary_header;
+    // How many more dynamic table updates are allowed
+    uint8_t dynamic_table_updates_allowed;
+    // Current parse state
+    ParseState parse_state = ParseState::kTop;
     absl::variant<const HPackTable::Memento*, Slice> key;
   };
 

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

@@ -29,7 +29,6 @@
 #include <utility>
 
 #include "absl/container/flat_hash_map.h"
-#include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
@@ -58,8 +57,10 @@
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
 #include "src/core/ext/transport/chttp2/transport/write_size_policy.h"
+#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/channel/tcp_tracer.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/bitset.h"
 #include "src/core/lib/gprpp/debug_location.h"
@@ -70,6 +71,7 @@
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/slice/slice.h"
@@ -78,8 +80,6 @@
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
-#include "src/core/lib/transport/transport_fwd.h"
-#include "src/core/lib/transport/transport_impl.h"
 
 // Flag that this closure barrier may be covering a write in a pollset, and so
 //   we should not complete this closure until we can prove that the write got
@@ -236,26 +236,40 @@ typedef enum {
   GRPC_CHTTP2_KEEPALIVE_STATE_DISABLED,
 } grpc_chttp2_keepalive_state;
 
-struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
+struct grpc_chttp2_transport final
+    : public grpc_core::Transport,
+      public grpc_core::FilterStackTransport,
+      public grpc_core::RefCounted<grpc_chttp2_transport,
+                                   grpc_core::NonPolymorphicRefCount>,
+      public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
                         grpc_endpoint* ep, bool is_client);
-  ~grpc_chttp2_transport();
-
-  // Make this be able to be contained in RefCountedPtr<>
-  // Can't yet make this derive from RefCounted because we need to keep
-  // `grpc_transport base` first.
-  // TODO(ctiller): Make a transport interface.
-  void IncrementRefCount() { refs.Ref(); }
-  void Unref() {
-    if (refs.Unref()) delete this;
-  }
-  grpc_core::RefCountedPtr<grpc_chttp2_transport> Ref() {
-    IncrementRefCount();
-    return grpc_core::RefCountedPtr<grpc_chttp2_transport>(this);
+  ~grpc_chttp2_transport() override;
+
+  void Orphan() override;
+
+  size_t SizeOfStream() const override;
+  bool HackyDisableStreamOpBatchCoalescingInConnectedChannel() const override;
+  void PerformStreamOp(grpc_stream* gs,
+                       grpc_transport_stream_op_batch* op) override;
+  void DestroyStream(grpc_stream* gs,
+                     grpc_closure* then_schedule_closure) override;
+
+  grpc_core::FilterStackTransport* filter_stack_transport() override {
+    return this;
   }
+  grpc_core::ClientTransport* client_transport() override { return nullptr; }
+  grpc_core::ServerTransport* server_transport() override { return nullptr; }
+
+  absl::string_view GetTransportName() const override;
+  void InitStream(grpc_stream* gs, grpc_stream_refcount* refcount,
+                  const void* server_data, grpc_core::Arena* arena) override;
+  void SetPollset(grpc_stream* stream, grpc_pollset* pollset) override;
+  void SetPollsetSet(grpc_stream* stream,
+                     grpc_pollset_set* pollset_set) override;
+  void PerformOp(grpc_transport_op* op) override;
+  grpc_endpoint* GetEndpoint() override;
 
-  grpc_transport base;  // must be first
-  grpc_core::RefCount refs;
   grpc_endpoint* ep;
   grpc_core::Slice peer_string;
 
@@ -305,7 +319,6 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   };
 
   grpc_closure write_action_begin_locked;
-  grpc_closure write_action;
   grpc_closure write_action_end_locked;
 
   grpc_closure read_action_locked;
@@ -319,7 +332,7 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_stream** accepting_stream = nullptr;
 
   // accept stream callback
-  void (*accept_stream_cb)(void* user_data, grpc_transport* transport,
+  void (*accept_stream_cb)(void* user_data, grpc_core::Transport* transport,
                            const void* server_data);
   // registered_method_matcher_cb is called before invoking the recv initial
   // metadata callback.
@@ -371,8 +384,9 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   grpc_core::Chttp2PingAbusePolicy ping_abuse_policy;
   grpc_core::Chttp2PingRatePolicy ping_rate_policy;
   grpc_core::Chttp2PingCallbacks ping_callbacks;
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
-      delayed_ping_timer_handle;
+  grpc_event_engine::experimental::EventEngine::TaskHandle
+      delayed_ping_timer_handle =
+          grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
   grpc_closure retry_initiate_ping_locked;
 
   grpc_core::Chttp2MaxConcurrentStreamsPolicy max_concurrent_streams_policy;
@@ -444,21 +458,20 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   grpc_closure destructive_reclaimer_locked;
 
   // next bdp ping timer handle
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
-      next_bdp_ping_timer_handle;
+  grpc_event_engine::experimental::EventEngine::TaskHandle
+      next_bdp_ping_timer_handle =
+          grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
 
   // keep-alive ping support
   /// Closure to initialize a keepalive ping
   grpc_closure init_keepalive_ping_locked;
-  /// Closure to run when the keepalive ping is sent
-  grpc_closure start_keepalive_ping_locked;
   /// Closure to run when the keepalive ping ack is received
   grpc_closure finish_keepalive_ping_locked;
-  /// Closure to run when the keepalive ping timeouts
-  grpc_closure keepalive_watchdog_fired_locked;
   /// timer to initiate ping events
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
-      keepalive_ping_timer_handle;
+  grpc_event_engine::experimental::EventEngine::TaskHandle
+      keepalive_ping_timer_handle =
+          grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
+  ;
   /// time duration in between pings
   grpc_core::Duration keepalive_time;
   /// grace period to wait for data after sending a ping before keepalives
@@ -492,6 +505,9 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   /// how much data are we willing to buffer when the WRITE_BUFFER_HINT is set?
   uint32_t write_buffer_size = grpc_core::chttp2::kDefaultWindow;
 
+  /// write execution state of the transport
+  grpc_chttp2_write_state write_state = GRPC_CHTTP2_WRITE_STATE_IDLE;
+
   /// policy for how much data we're willing to put into one http2 write
   grpc_core::Chttp2WriteSizePolicy write_size_policy;
 
@@ -511,8 +527,6 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
 
   /// if keepalive pings are allowed when there's no outstanding streams
   bool keepalive_permit_without_calls = false;
-  /// If start_keepalive_ping_locked has been called
-  bool keepalive_ping_started = false;
 
   // bdp estimator
   bool bdp_ping_blocked =
@@ -521,9 +535,6 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   /// is the transport destroying itself?
   uint8_t destroying = false;
 
-  /// is there a read request to the endpoint outstanding?
-  uint8_t endpoint_reading = 1;
-
   /// is this a client?
   bool is_client;
 
@@ -538,13 +549,13 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   bool ack_pings = true;
   /// True if the keepalive system wants to see some data incoming
   bool keepalive_incoming_data_wanted = false;
+  /// True if we count stream allocation (instead of HTTP2 concurrency) for
+  /// MAX_CONCURRENT_STREAMS
+  bool max_concurrent_streams_overload_protection = false;
 
   // What percentage of rst_stream frames on the server should cause a ping
   // frame to be generated.
   uint8_t ping_on_rst_stream_percent;
-
-  /// write execution state of the transport
-  grpc_chttp2_write_state write_state = GRPC_CHTTP2_WRITE_STATE_IDLE;
 };
 
 typedef enum {
@@ -650,6 +661,12 @@ struct grpc_chttp2_stream {
   /// Byte counter for number of bytes written
   size_t byte_counter = 0;
 
+  /// Only set when enabled.
+  grpc_core::CallTracerInterface* call_tracer = nullptr;
+
+  /// Only set when enabled.
+  std::shared_ptr<grpc_core::TcpTracerInterface> tcp_tracer;
+
   // time this stream was created
   gpr_timespec creation_time = gpr_now(GPR_CLOCK_MONOTONIC);
 
@@ -670,6 +687,12 @@ struct grpc_chttp2_stream {
 
 #define GRPC_ARG_PING_TIMEOUT_MS "grpc.http2.ping_timeout_ms"
 
+// EXPERIMENTAL: provide protection against overloading a server with too many
+// requests: wait for streams to be deallocated before they stop counting
+// against MAX_CONCURRENT_STREAMS
+#define GRPC_ARG_MAX_CONCURRENT_STREAMS_OVERLOAD_PROTECTION \
+  "grpc.http.overload_protection"
+
 /// Transport writing call flow:
 /// grpc_chttp2_initiate_write() is called anywhere that we know bytes need to
 /// go out on the wire.

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

@@ -651,9 +651,19 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                    t->stream_map.size() + t->extra_streams >=
                    t->settings[GRPC_ACKED_SETTINGS]
                               [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])) {
-      return GRPC_ERROR_CREATE("Max stream count exceeded");
+      if (grpc_core::IsRfcMaxConcurrentStreamsEnabled()) {
+        ++t->num_pending_induced_frames;
+        grpc_slice_buffer_add(
+            &t->qbuf,
+            grpc_chttp2_rst_stream_create(t->incoming_stream_id,
+                                          GRPC_HTTP2_REFUSED_STREAM, nullptr));
+        grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
+        return init_header_skip_frame_parser(t, priority_type, is_eoh);
+      } else {
+        return GRPC_ERROR_CREATE("Max stream count exceeded");
+      }
     } else if (GPR_UNLIKELY(
-                   grpc_core::IsOverloadProtectionEnabled() &&
+                   t->max_concurrent_streams_overload_protection &&
                    t->streams_allocated.load(std::memory_order_relaxed) >
                        t->max_concurrent_streams_policy.AdvertiseValue())) {
       // We have more streams allocated than we'd like, so apply some pushback

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

@@ -18,7 +18,6 @@
 
 #include <algorithm>
 #include <ostream>
-#include <utility>
 
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
@@ -68,7 +67,7 @@ Chttp2PingRatePolicy::RequestSendPing(Duration next_allowed_ping_interval,
   if (max_pings_without_data_ != 0 && pings_before_data_required_ == 0) {
     return TooManyRecentPings{};
   }
-  if (max_inflight_pings_ != 0 &&
+  if (max_inflight_pings_ > 0 &&
       inflight_pings > static_cast<size_t>(max_inflight_pings_)) {
     return TooManyRecentPings{};
   }