grpc 1.58.0 → 1.60.0

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

@@ -0,0 +1,67 @@
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MAX_CONCURRENT_STREAMS_POLICY_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MAX_CONCURRENT_STREAMS_POLICY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <cstdint>
+#include <limits>
+
+namespace grpc_core {
+
+class Chttp2MaxConcurrentStreamsPolicy {
+ public:
+  // Set the target number of concurrent streams.
+  // If everything is idle we should advertise this number.
+  void SetTarget(uint32_t target) { target_ = target; }
+
+  // Add one demerit to the current target.
+  // We need to do one full settings round trip after this to clear this
+  // demerit.
+  // It will reduce our advertised max concurrent streams by one.
+  void AddDemerit();
+
+  // Notify the policy that we've sent a settings frame.
+  // Newly added demerits since the last settings frame was sent will be cleared
+  // once that settings frame is acknowledged.
+  void FlushedSettings();
+
+  // Notify the policy that we've received an acknowledgement for the last
+  // settings frame we sent.
+  void AckLastSend();
+
+  // Returns what we should advertise as max concurrent streams.
+  uint32_t AdvertiseValue() const;
+
+ private:
+  uint32_t target_ = std::numeric_limits<int32_t>::max();
+  // Demerit flow:
+  // When we add a demerit, we add to both new & unacked.
+  // When we flush settings, we move new to sent.
+  // When we ack settings, we remove what we sent from unacked.
+  // eg:
+  // we add 10 demerits - now new=10, sent=0, unacked=10
+  // we send settings - now new=0, sent=10, unacked=10
+  // we add 5 demerits - now new=5, sent=10, unacked=15
+  // we get the settings ack - now new=5, sent=0, unacked=5
+  uint32_t new_demerits_ = 0;
+  uint32_t sent_demerits_ = 0;
+  uint32_t unacked_demerits_ = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_MAX_CONCURRENT_STREAMS_POLICY_H

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

@@ -21,21 +21,28 @@
 #include <inttypes.h>
 #include <string.h>
 
+#include <atomic>
 #include <initializer_list>
+#include <limits>
+#include <memory>
 #include <string>
+#include <utility>
 
 #include "absl/base/attributes.h"
 #include "absl/container/flat_hash_map.h"
+#include "absl/random/bit_gen_ref.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
 #include <grpc/support/log.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/frame_data.h"
 #include "src/core/ext/transport/chttp2/transport/frame_goaway.h"
 #include "src/core/ext/transport/chttp2/transport/frame_ping.h"
@@ -47,11 +54,15 @@
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
 #include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
+#include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
+#include "src/core/ext/transport/chttp2/transport/max_concurrent_streams_policy.h"
 #include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
+#include "src/core/lib/backoff/random_early_detection.h"
 #include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -69,9 +80,11 @@ using grpc_core::HPackParser;
 
 grpc_core::TraceFlag grpc_trace_chttp2_new_stream(false, "chttp2_new_stream");
 
-static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t);
+static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
+                                           size_t& requests_started);
 static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
-                                                  int is_continuation);
+                                                  int is_continuation,
+                                                  size_t& requests_started);
 static grpc_error_handle init_data_frame_parser(grpc_chttp2_transport* t);
 static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t);
 static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t);
@@ -193,8 +206,9 @@ std::string FrameTypeString(uint8_t frame_type, uint8_t flags) {
 }
 }  // namespace
 
-grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
-                                           const grpc_slice& slice) {
+absl::variant<size_t, absl::Status> grpc_chttp2_perform_read(
+    grpc_chttp2_transport* t, const grpc_slice& slice,
+    size_t& requests_started) {
   const uint8_t* beg = GRPC_SLICE_START_PTR(slice);
   const uint8_t* end = GRPC_SLICE_END_PTR(slice);
   const uint8_t* cur = beg;
@@ -248,6 +262,10 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         return absl::OkStatus();
       }
     dts_fh_0:
+      if (requests_started >= t->max_requests_per_read) {
+        t->deframe_state = GRPC_DTS_FH_0;
+        return static_cast<size_t>(cur - beg);
+      }
       ABSL_FALLTHROUGH_INTENDED;
     case GRPC_DTS_FH_0:
       GPR_DEBUG_ASSERT(cur < end);
@@ -323,7 +341,7 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
                 t->incoming_frame_size, t->incoming_stream_id);
       }
       t->deframe_state = GRPC_DTS_FRAME;
-      err = init_frame_parser(t);
+      err = init_frame_parser(t, requests_started);
       if (!err.ok()) {
         return err;
       }
@@ -377,6 +395,10 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
         }
         cur += t->incoming_frame_size;
         t->incoming_stream = nullptr;
+        if (t->incoming_frame_type == GRPC_CHTTP2_FRAME_RST_STREAM &&
+            grpc_core::IsChttp2OffloadOnRstStreamEnabled()) {
+          requests_started = std::numeric_limits<size_t>::max();
+        }
         goto dts_fh_0;  // loop
       } else {
         err = parse_frame_slice(
@@ -396,7 +418,8 @@ grpc_error_handle grpc_chttp2_perform_read(grpc_chttp2_transport* t,
   GPR_UNREACHABLE_CODE(return absl::OkStatus());
 }
 
-static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t) {
+static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t,
+                                           size_t& requests_started) {
   if (t->is_first_frame &&
       t->incoming_frame_type != GRPC_CHTTP2_FRAME_SETTINGS) {
     return GRPC_ERROR_CREATE(absl::StrCat(
@@ -416,13 +439,13 @@ static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t) {
           "grpc_chttp2_stream %08x",
           t->expect_continuation_stream_id, t->incoming_stream_id));
     }
-    return init_header_frame_parser(t, 1);
+    return init_header_frame_parser(t, 1, requests_started);
   }
   switch (t->incoming_frame_type) {
     case GRPC_CHTTP2_FRAME_DATA:
       return init_data_frame_parser(t);
     case GRPC_CHTTP2_FRAME_HEADER:
-      return init_header_frame_parser(t, 0);
+      return init_header_frame_parser(t, 0, requests_started);
     case GRPC_CHTTP2_FRAME_CONTINUATION:
       return GRPC_ERROR_CREATE("Unexpected CONTINUATION frame");
     case GRPC_CHTTP2_FRAME_RST_STREAM:
@@ -566,7 +589,8 @@ error_handler:
 }
 
 static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
-                                                  int is_continuation) {
+                                                  int is_continuation,
+                                                  size_t& requests_started) {
   const bool is_eoh =
       (t->incoming_frame_flags & GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0;
   grpc_chttp2_stream* s;
@@ -624,10 +648,50 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           t->incoming_stream_id));
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY(
-                   t->stream_map.size() >=
+                   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(
+                   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
+      // by refusing this stream.
+      ++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 if (GPR_UNLIKELY(
+                   grpc_core::IsRedMaxConcurrentStreamsEnabled() &&
+                   t->stream_map.size() >=
+                       t->max_concurrent_streams_policy.AdvertiseValue() &&
+                   grpc_core::RandomEarlyDetection(
+                       t->max_concurrent_streams_policy.AdvertiseValue(),
+                       t->settings[GRPC_ACKED_SETTINGS]
+                                  [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])
+                       .Reject(t->stream_map.size(), t->bitgen))) {
+      // We are under the limit of max concurrent streams for the current
+      // setting, but are over the next value that will be advertised.
+      // Apply some backpressure by randomly not accepting new streams.
+      ++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 if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT ||
                t->sent_goaway_state ==
                    GRPC_CHTTP2_FINAL_GOAWAY_SEND_SCHEDULED) {
@@ -638,10 +702,29 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           t, std::string(t->peer_string.as_string_view()).c_str(),
           t->incoming_stream_id, t->last_new_stream_id));
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
+    } else if (grpc_core::IsBlockExcessiveRequestsBeforeSettingsAckEnabled() &&
+               t->num_incoming_streams_before_settings_ack == 0) {
+      GRPC_CHTTP2_IF_TRACING(gpr_log(
+          GPR_ERROR,
+          "transport:%p SERVER peer:%s rejecting grpc_chttp2_stream id=%d, "
+          "last grpc_chttp2_stream id=%d before settings have been "
+          "acknowledged",
+          t, std::string(t->peer_string.as_string_view()).c_str(),
+          t->incoming_stream_id, t->last_new_stream_id));
+      ++t->num_pending_induced_frames;
+      grpc_slice_buffer_add(
+          &t->qbuf,
+          grpc_chttp2_rst_stream_create(t->incoming_stream_id,
+                                        GRPC_HTTP2_ENHANCE_YOUR_CALM, nullptr));
+      grpc_chttp2_initiate_write(t, GRPC_CHTTP2_INITIATE_WRITE_RST_STREAM);
+      t->last_new_stream_id = t->incoming_stream_id;
+      return init_header_skip_frame_parser(t, priority_type, is_eoh);
     }
+    --t->num_incoming_streams_before_settings_ack;
     t->last_new_stream_id = t->incoming_stream_id;
     s = t->incoming_stream =
         grpc_chttp2_parsing_accept_stream(t, t->incoming_stream_id);
+    ++requests_started;
     if (GPR_UNLIKELY(s == nullptr)) {
       GRPC_CHTTP2_IF_TRACING(
           gpr_log(GPR_ERROR, "grpc_chttp2_stream not accepted"));
@@ -649,9 +732,12 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
     }
     if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
         GRPC_TRACE_FLAG_ENABLED(grpc_trace_chttp2_new_stream)) {
-      gpr_log(GPR_INFO, "[t:%p fd:%d peer:%s] Accepting new stream", t,
-              grpc_endpoint_get_fd(t->ep),
-              std::string(t->peer_string.as_string_view()).c_str());
+      gpr_log(GPR_INFO,
+              "[t:%p fd:%d peer:%s] Accepting new stream; "
+              "num_incoming_streams_before_settings_ack=%u",
+              t, grpc_endpoint_get_fd(t->ep),
+              std::string(t->peer_string.as_string_view()).c_str(),
+              t->num_incoming_streams_before_settings_ack);
     }
     if (t->channelz_socket != nullptr) {
       t->channelz_socket->RecordStreamStartedFromRemote();
@@ -762,6 +848,9 @@ static grpc_error_handle init_rst_stream_parser(grpc_chttp2_transport* t) {
   s->stats.incoming.framing_bytes += 9;
   t->parser = grpc_chttp2_transport::Parser{
       "rst_stream", grpc_chttp2_rst_stream_parser_parse, &t->simple.rst_stream};
+  if (!t->is_client && grpc_core::IsRstpitEnabled()) {
+    t->max_concurrent_streams_policy.AddDemerit();
+  }
   return absl::OkStatus();
 }
 
@@ -786,6 +875,7 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
     return err;
   }
   if (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_ACK) {
+    t->max_concurrent_streams_policy.AckLastSend();
     memcpy(t->settings[GRPC_ACKED_SETTINGS], t->settings[GRPC_SENT_SETTINGS],
            GRPC_CHTTP2_NUM_SETTINGS * sizeof(uint32_t));
     t->hpack_parser.hpack_table()->SetMaxBytes(
@@ -796,7 +886,17 @@ static grpc_error_handle init_settings_frame_parser(grpc_chttp2_transport* t) {
             t->settings[GRPC_ACKED_SETTINGS]
                        [GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE]),
         t, nullptr);
+    if (t->settings_ack_watchdog !=
+        grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid) {
+      t->event_engine->Cancel(std::exchange(
+          t->settings_ack_watchdog,
+          grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid));
+    }
     t->sent_local_settings = false;
+    // This is more streams than can be started in http2, so setting this
+    // effictively removes the limit for the rest of the connection.
+    t->num_incoming_streams_before_settings_ack =
+        std::numeric_limits<uint32_t>::max();
   }
   t->parser = grpc_chttp2_transport::Parser{
       "settings", grpc_chttp2_settings_parser_parse, &t->simple.settings};
@@ -827,7 +927,7 @@ static grpc_error_handle parse_frame_slice(grpc_chttp2_transport* t,
                          &unused)) {
     grpc_chttp2_parsing_become_skip_parser(t);
     if (s) {
-      grpc_chttp2_cancel_stream(t, s, err);
+      grpc_chttp2_cancel_stream(t, s, err, true);
     }
     return absl::OkStatus();
   }
@@ -869,7 +969,8 @@ grpc_error_handle grpc_chttp2_header_parser_parse(void* hpack_parser,
               .value);
     }
   }
-  grpc_error_handle error = parser->Parse(slice, is_last != 0, call_tracer);
+  grpc_error_handle error = parser->Parse(
+      slice, is_last != 0, absl::BitGenRef(t->bitgen), call_tracer);
   if (!error.ok()) {
     return error;
   }

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

@@ -18,6 +18,7 @@
 
 #include <algorithm>
 
+#include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 
 #include <grpc/impl/channel_arg_names.h>
@@ -61,6 +62,15 @@ bool Chttp2PingAbusePolicy::ReceivedOnePing(bool transport_idle) {
   return ping_strikes_ > max_ping_strikes_ && max_ping_strikes_ != 0;
 }
 
+std::string Chttp2PingAbusePolicy::GetDebugString(bool transport_idle) const {
+  return absl::StrCat(
+      "now=", Timestamp::Now().ToString(), " transport_idle=", transport_idle,
+      " next_allowed_ping=",
+      (last_ping_recv_time_ + RecvPingIntervalWithoutData(transport_idle))
+          .ToString(),
+      " ping_strikes=", ping_strikes_);
+}
+
 Duration Chttp2PingAbusePolicy::RecvPingIntervalWithoutData(
     bool transport_idle) const {
   if (transport_idle) {

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

@@ -17,6 +17,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/time.h"
 
@@ -41,6 +43,8 @@ class Chttp2PingAbusePolicy {
     return min_recv_ping_interval_without_data_;
   }
 
+  std::string GetDebugString(bool transport_idle) const;
+
  private:
   Duration RecvPingIntervalWithoutData(bool transport_idle) const;
 

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

@@ -0,0 +1,108 @@
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
+
+#include <utility>
+
+#include "absl/meta/type_traits.h"
+#include "absl/random/distributions.h"
+
+#include <grpc/support/log.h>
+
+grpc_core::TraceFlag grpc_ping_trace(false, "http2_ping");
+
+namespace grpc_core {
+
+void Chttp2PingCallbacks::OnPing(Callback on_start, Callback on_ack) {
+  on_start_.emplace_back(std::move(on_start));
+  on_ack_.emplace_back(std::move(on_ack));
+  ping_requested_ = true;
+}
+
+void Chttp2PingCallbacks::OnPingAck(Callback on_ack) {
+  auto it = inflight_.find(most_recent_inflight_);
+  if (it != inflight_.end()) {
+    it->second.on_ack.emplace_back(std::move(on_ack));
+    return;
+  }
+  ping_requested_ = true;
+  on_ack_.emplace_back(std::move(on_ack));
+}
+
+uint64_t Chttp2PingCallbacks::StartPing(absl::BitGenRef bitgen) {
+  uint64_t id;
+  do {
+    id = absl::Uniform<uint64_t>(bitgen);
+  } while (inflight_.contains(id));
+  CallbackVec cbs = std::move(on_start_);
+  CallbackVec().swap(on_start_);
+  InflightPing inflight;
+  inflight.on_ack.swap(on_ack_);
+  started_new_ping_without_setting_timeout_ = true;
+  inflight_.emplace(id, std::move(inflight));
+  most_recent_inflight_ = id;
+  ping_requested_ = false;
+  for (auto& cb : cbs) {
+    cb();
+  }
+  return id;
+}
+
+bool Chttp2PingCallbacks::AckPing(
+    uint64_t id, grpc_event_engine::experimental::EventEngine* event_engine) {
+  auto ping = inflight_.extract(id);
+  if (ping.empty()) return false;
+  if (ping.mapped().on_timeout !=
+      grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid) {
+    event_engine->Cancel(ping.mapped().on_timeout);
+  }
+  for (auto& cb : ping.mapped().on_ack) {
+    cb();
+  }
+  return true;
+}
+
+void Chttp2PingCallbacks::CancelAll(
+    grpc_event_engine::experimental::EventEngine* event_engine) {
+  CallbackVec().swap(on_start_);
+  CallbackVec().swap(on_ack_);
+  for (auto& cbs : inflight_) {
+    CallbackVec().swap(cbs.second.on_ack);
+    if (cbs.second.on_timeout !=
+        grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid) {
+      event_engine->Cancel(std::exchange(
+          cbs.second.on_timeout,
+          grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid));
+    }
+  }
+  ping_requested_ = false;
+}
+
+absl::optional<uint64_t> Chttp2PingCallbacks::OnPingTimeout(
+    Duration ping_timeout,
+    grpc_event_engine::experimental::EventEngine* event_engine,
+    Callback callback) {
+  GPR_ASSERT(started_new_ping_without_setting_timeout_);
+  started_new_ping_without_setting_timeout_ = false;
+  auto it = inflight_.find(most_recent_inflight_);
+  if (it == inflight_.end()) return absl::nullopt;
+  it->second.on_timeout =
+      event_engine->RunAfter(ping_timeout, std::move(callback));
+  return most_recent_inflight_;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,115 @@
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_CALLBACKS_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_CALLBACKS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/hash/hash.h"
+#include "absl/random/bit_gen_ref.h"
+#include "absl/types/optional.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/time.h"
+
+extern grpc_core::TraceFlag grpc_ping_trace;
+
+namespace grpc_core {
+
+class Chttp2PingCallbacks {
+ public:
+  // One callback from OnPing/OnPingAck or the timeout.
+  using Callback = absl::AnyInvocable<void()>;
+
+  // Request a ping (but one we don't need any notification for when it begins
+  // or ends).
+  void RequestPing() { ping_requested_ = true; }
+
+  // Request a ping, and specify callbacks for when it begins and ends.
+  // on_start is invoked during the call to StartPing.
+  // on_ack is invoked during the call to AckPing.
+  void OnPing(Callback on_start, Callback on_ack);
+
+  // Request a notification when *some* ping is acked:
+  // If there is no ping in flight, one will be scheduled and the callback
+  // will be invoked when it is acked. (ie as per OnPing([]{}, on_ack)).
+  // If there is a ping in flight, the callback will be invoked when the most
+  // recently sent ping is acked.
+  // on_ack is invoked during the call to AckPing.
+  void OnPingAck(Callback on_ack);
+
+  // Write path: begin a ping.
+  // Uses bitgen to generate a randomized id for the ping.
+  // Sets started_new_ping_without_setting_timeout.
+  GRPC_MUST_USE_RESULT uint64_t StartPing(absl::BitGenRef bitgen);
+  bool AckPing(uint64_t id,
+               grpc_event_engine::experimental::EventEngine* event_engine);
+
+  // Cancel all the ping callbacks.
+  // Sufficient state is maintained such that AckPing will still return true
+  // if a ping is acked after this call.
+  // No timeouts or start or ack callbacks previously scheduled will be invoked.
+  void CancelAll(grpc_event_engine::experimental::EventEngine* event_engine);
+
+  // Return true if a ping needs to be started due to
+  // RequestPing/OnPing/OnPingAck.
+  bool ping_requested() const { return ping_requested_; }
+
+  // Returns the number of pings currently in flight.
+  size_t pings_inflight() const { return inflight_.size(); }
+
+  // Returns true if a ping was started without setting a timeout yet.
+  bool started_new_ping_without_setting_timeout() const {
+    return started_new_ping_without_setting_timeout_;
+  }
+
+  // Add a ping timeout for the most recently started ping.
+  // started_new_ping_without_setting_timeout must be set.
+  // Clears started_new_ping_without_setting_timeout.
+  // Returns the ping id of the ping the timeout was attached to if a timer was
+  // started, or nullopt otherwise.
+  absl::optional<uint64_t> OnPingTimeout(
+      Duration ping_timeout,
+      grpc_event_engine::experimental::EventEngine* event_engine,
+      Callback callback);
+
+ private:
+  using CallbackVec = std::vector<Callback>;
+  struct InflightPing {
+    grpc_event_engine::experimental::EventEngine::TaskHandle on_timeout =
+        grpc_event_engine::experimental::EventEngine::TaskHandle::kInvalid;
+    CallbackVec on_ack;
+  };
+  absl::flat_hash_map<uint64_t, InflightPing> inflight_;
+  uint64_t most_recent_inflight_ = 0;
+  bool ping_requested_ = false;
+  bool started_new_ping_without_setting_timeout_ = false;
+  CallbackVec on_start_;
+  CallbackVec on_ack_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_CALLBACKS_H