grpc 1.55.0 → 1.56.2

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

@@ -21,7 +21,6 @@
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 
 #include <inttypes.h>
-#include <limits.h>
 
 #include <algorithm>
 #include <cmath>
@@ -245,7 +244,7 @@ TransportFlowControl::TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
   //
   //          ▲
   //          │
-  // 16mb ────┤---------x----
+  //  4mb ────┤---------x----
   //          │              -----
   //  BDP ────┤                   ----x---
   //          │                           ----
@@ -260,7 +259,8 @@ TransportFlowControl::TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
   //                                                                pressure
   const double kAnythingGoesPressure = 0.2;
   const double kAdjustedToBdpPressure = 0.5;
-  const double kAnythingGoesWindow = std::max(double{1 << 24}, bdp);
+  const double kOneMegabyte = 1024.0 * 1024.0;
+  const double kAnythingGoesWindow = std::max(4.0 * kOneMegabyte, bdp);
   if (memory_pressure < kAnythingGoesPressure) {
     return kAnythingGoesWindow;
   } else if (memory_pressure < kAdjustedToBdpPressure) {
@@ -278,45 +278,33 @@ void TransportFlowControl::UpdateSetting(
     uint32_t new_desired_value, FlowControlAction* action,
     FlowControlAction& (FlowControlAction::*set)(FlowControlAction::Urgency,
                                                  uint32_t)) {
-  if (IsFlowControlFixesEnabled()) {
-    new_desired_value =
-        Clamp(new_desired_value, grpc_chttp2_settings_parameters[id].min_value,
-              grpc_chttp2_settings_parameters[id].max_value);
-    if (new_desired_value != *desired_value) {
-      if (grpc_flowctl_trace.enabled()) {
-        gpr_log(GPR_INFO, "[flowctl] UPDATE SETTING %s from %" PRId64 " to %d",
-                grpc_chttp2_settings_parameters[id].name, *desired_value,
-                new_desired_value);
-      }
-      // Reaching zero can only happen for initial window size, and if it occurs
-      // we really want to wake up writes and ensure all the queued stream
-      // window updates are flushed, since stream flow control operates
-      // differently at zero window size.
-      FlowControlAction::Urgency urgency =
-          FlowControlAction::Urgency::QUEUE_UPDATE;
-      if (*desired_value == 0 || new_desired_value == 0) {
-        urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
-      }
-      *desired_value = new_desired_value;
-      (action->*set)(urgency, *desired_value);
+  new_desired_value =
+      Clamp(new_desired_value, grpc_chttp2_settings_parameters[id].min_value,
+            grpc_chttp2_settings_parameters[id].max_value);
+  if (new_desired_value != *desired_value) {
+    if (grpc_flowctl_trace.enabled()) {
+      gpr_log(GPR_INFO, "[flowctl] UPDATE SETTING %s from %" PRId64 " to %d",
+              grpc_chttp2_settings_parameters[id].name, *desired_value,
+              new_desired_value);
     }
-  } else {
-    int64_t delta = new_desired_value - *desired_value;
-    // TODO(ncteisen): tune this
-    if (delta != 0 &&
-        (delta <= -*desired_value / 5 || delta >= *desired_value / 5)) {
-      *desired_value = new_desired_value;
-      (action->*set)(FlowControlAction::Urgency::QUEUE_UPDATE,
-                     static_cast<uint32_t>(*desired_value));
+    // Reaching zero can only happen for initial window size, and if it occurs
+    // we really want to wake up writes and ensure all the queued stream
+    // window updates are flushed, since stream flow control operates
+    // differently at zero window size.
+    FlowControlAction::Urgency urgency =
+        FlowControlAction::Urgency::QUEUE_UPDATE;
+    if (*desired_value == 0 || new_desired_value == 0) {
+      urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
     }
+    *desired_value = new_desired_value;
+    (action->*set)(urgency, *desired_value);
   }
 }
 
 FlowControlAction TransportFlowControl::SetAckedInitialWindow(uint32_t value) {
   acked_init_window_ = value;
   FlowControlAction action;
-  if (IsFlowControlFixesEnabled() &&
-      acked_init_window_ != target_initial_window_size_) {
+  if (acked_init_window_ != target_initial_window_size_) {
     FlowControlAction::Urgency urgency =
         FlowControlAction::Urgency::QUEUE_UPDATE;
     if (acked_init_window_ == 0 || target_initial_window_size_ == 0) {
@@ -330,68 +318,31 @@ FlowControlAction TransportFlowControl::SetAckedInitialWindow(uint32_t value) {
 FlowControlAction TransportFlowControl::PeriodicUpdate() {
   FlowControlAction action;
   if (enable_bdp_probe_) {
-    if (IsFlowControlFixesEnabled()) {
-      // get bdp estimate and update initial_window accordingly.
-      // target might change based on how much memory pressure we are under
-      // TODO(ncteisen): experiment with setting target to be huge under low
-      // memory pressure.
-      uint32_t target = static_cast<uint32_t>(RoundUpToPowerOf2(
-          Clamp(IsMemoryPressureControllerEnabled()
-                    ? TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
-                    : pow(2, SmoothLogBdp(TargetLogBdp())),
-                0.0, static_cast<double>(kMaxInitialWindowSize))));
-      if (target < kMinPositiveInitialWindowSize) target = 0;
-      if (g_test_only_transport_target_window_estimates_mocker != nullptr) {
-        // Hook for simulating unusual flow control situations in tests.
-        target = g_test_only_transport_target_window_estimates_mocker
-                     ->ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
-                         target_initial_window_size_ /* current target */);
-      }
-      // Though initial window 'could' drop to 0, we keep the floor at
-      // kMinInitialWindowSize
-      UpdateSetting(GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
-                    &target_initial_window_size_, target, &action,
-                    &FlowControlAction::set_send_initial_window_update);
-      // we target the max of BDP or bandwidth in microseconds.
-      UpdateSetting(GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE, &target_frame_size_,
-                    target, &action,
-                    &FlowControlAction::set_send_max_frame_size_update);
-    } else {
-      // get bdp estimate and update initial_window accordingly.
-      // target might change based on how much memory pressure we are under
-      // TODO(ncteisen): experiment with setting target to be huge under low
-      // memory pressure.
-      double target = IsMemoryPressureControllerEnabled()
-                          ? TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
-                          : pow(2, SmoothLogBdp(TargetLogBdp()));
-      if (g_test_only_transport_target_window_estimates_mocker != nullptr) {
-        // Hook for simulating unusual flow control situations in tests.
-        target = g_test_only_transport_target_window_estimates_mocker
-                     ->ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
-                         target_initial_window_size_ /* current target */);
-      }
-      // Though initial window 'could' drop to 0, we keep the floor at
-      // kMinInitialWindowSize
-      UpdateSetting(GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
-                    &target_initial_window_size_,
-                    static_cast<int32_t>(Clamp(
-                        target, static_cast<double>(kMinInitialWindowSize),
-                        static_cast<double>(kMaxInitialWindowSize))),
-                    &action,
-                    &FlowControlAction::set_send_initial_window_update);
-      // get bandwidth estimate and update max_frame accordingly.
-      double bw_dbl = bdp_estimator_.EstimateBandwidth();
-      // we target the max of BDP or bandwidth in microseconds.
-      UpdateSetting(
-          GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE, &target_frame_size_,
-          static_cast<int32_t>(
-              Clamp(std::max(static_cast<int32_t>(Clamp(
-                                 bw_dbl, 0.0, static_cast<double>(INT_MAX))) /
-                                 1000,
-                             static_cast<int32_t>(target_initial_window_size_)),
-                    16384, 16777215)),
-          &action, &FlowControlAction::set_send_max_frame_size_update);
+    // get bdp estimate and update initial_window accordingly.
+    // target might change based on how much memory pressure we are under
+    // TODO(ncteisen): experiment with setting target to be huge under low
+    // memory pressure.
+    uint32_t target = static_cast<uint32_t>(RoundUpToPowerOf2(
+        Clamp(IsMemoryPressureControllerEnabled()
+                  ? TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
+                  : pow(2, SmoothLogBdp(TargetLogBdp())),
+              0.0, static_cast<double>(kMaxInitialWindowSize))));
+    if (target < kMinPositiveInitialWindowSize) target = 0;
+    if (g_test_only_transport_target_window_estimates_mocker != nullptr) {
+      // Hook for simulating unusual flow control situations in tests.
+      target = g_test_only_transport_target_window_estimates_mocker
+                   ->ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
+                       target_initial_window_size_ /* current target */);
     }
+    // Though initial window 'could' drop to 0, we keep the floor at
+    // kMinInitialWindowSize
+    UpdateSetting(GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
+                  &target_initial_window_size_, target, &action,
+                  &FlowControlAction::set_send_initial_window_update);
+    // we target the max of BDP or bandwidth in microseconds.
+    UpdateSetting(GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE, &target_frame_size_,
+                  target, &action,
+                  &FlowControlAction::set_send_max_frame_size_update);
 
     if (IsTcpFrameSizeTuningEnabled()) {
       // Advertise PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE to peer. By advertising

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

@@ -0,0 +1,176 @@
+// 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/hpack_parse_result.h"
+
+#include <stddef.h>
+
+#include <initializer_list>
+
+#include "absl/strings/str_format.h"
+
+#include "src/core/ext/transport/chttp2/transport/hpack_constants.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+namespace {
+class MetadataSizeLimitExceededEncoder {
+ public:
+  explicit MetadataSizeLimitExceededEncoder(std::string& summary)
+      : summary_(summary) {}
+
+  void Encode(const Slice& key, const Slice& value) {
+    AddToSummary(key.as_string_view(), value.size());
+  }
+
+  template <typename Key, typename Value>
+  void Encode(Key, const Value& value) {
+    AddToSummary(Key::key(), EncodedSizeOfKey(Key(), value));
+  }
+
+ private:
+  void AddToSummary(absl::string_view key,
+                    size_t value_length) GPR_ATTRIBUTE_NOINLINE {
+    absl::StrAppend(&summary_, " ", key, ":",
+                    hpack_constants::SizeForEntry(key.size(), value_length),
+                    "B");
+  }
+  std::string& summary_;
+};
+
+absl::Status MakeStreamError(absl::Status error) {
+  GPR_DEBUG_ASSERT(!error.ok());
+  return grpc_error_set_int(std::move(error), StatusIntProperty::kStreamId, 0);
+}
+}  // namespace
+
+absl::Status HpackParseResult::Materialize() const {
+  if (materialized_status_.has_value()) return *materialized_status_;
+  materialized_status_ = BuildMaterialized();
+  return *materialized_status_;
+}
+
+absl::Status HpackParseResult::BuildMaterialized() const {
+  switch (status_.get()) {
+    case HpackParseStatus::kOk:
+      return absl::OkStatus();
+    case HpackParseStatus::kEof:
+      Crash("Materialize() called on EOF");
+      break;
+    case HpackParseStatus::kMovedFrom:
+      Crash("Materialize() called on moved-from object");
+      break;
+    case HpackParseStatus::kInvalidMetadata:
+      if (key_.empty()) {
+        return MakeStreamError(absl::InternalError(
+            ValidateMetadataResultToString(validate_metadata_result_)));
+      } else {
+        return MakeStreamError(absl::InternalError(absl::StrCat(
+            ValidateMetadataResultToString(validate_metadata_result_), ": ",
+            key_)));
+      }
+    case HpackParseStatus::kSoftMetadataLimitExceeded:
+    case HpackParseStatus::kHardMetadataLimitExceeded: {
+      const auto& e = metadata_limit_exceeded_;
+      // Collect a summary of sizes so far for debugging
+      // Do not collect contents, for fear of exposing PII.
+      std::string summary;
+      if (e.prior != nullptr) {
+        MetadataSizeLimitExceededEncoder encoder(summary);
+        e.prior->Encode(&encoder);
+      }
+      return MakeStreamError(absl::ResourceExhaustedError(absl::StrCat(
+          "received metadata size exceeds ",
+          status_.get() == HpackParseStatus::kSoftMetadataLimitExceeded
+              ? "soft"
+              : "hard",
+          " limit (", e.frame_length, " vs. ", e.limit, ")",
+          summary.empty() ? "" : "; ", summary)));
+    }
+    case HpackParseStatus::kHardMetadataLimitExceededByKey: {
+      const auto& e = metadata_limit_exceeded_by_atom_;
+      return MakeStreamError(absl::ResourceExhaustedError(
+          absl::StrCat("received metadata size exceeds hard limit (key length ",
+                       e.atom_length, " vs. ", e.limit, ")")));
+    }
+    case HpackParseStatus::kHardMetadataLimitExceededByValue: {
+      const auto& e = metadata_limit_exceeded_by_atom_;
+      return MakeStreamError(absl::ResourceExhaustedError(absl::StrCat(
+          "received metadata size exceeds hard limit (value length ",
+          e.atom_length, " vs. ", e.limit, ")")));
+    }
+    case HpackParseStatus::kMetadataParseError:
+      if (!key_.empty()) {
+        return MakeStreamError(absl::InternalError(
+            absl::StrCat("Error parsing '", key_, "' metadata")));
+      } else {
+        return MakeStreamError(absl::InternalError("Error parsing metadata"));
+      }
+    case HpackParseStatus::kUnbase64Failed:
+      if (!key_.empty()) {
+        return MakeStreamError(absl::InternalError(absl::StrCat(
+            "Error parsing '", key_, "' metadata: illegal base64 encoding")));
+      } else {
+        return MakeStreamError(absl::InternalError(
+            absl::StrCat("Failed base64 decoding metadata")));
+      }
+    case HpackParseStatus::kIncompleteHeaderAtBoundary:
+      return absl::InternalError(
+          "Incomplete header at the end of a header/continuation sequence");
+    case HpackParseStatus::kVarintOutOfRange:
+      return absl::InternalError(absl::StrFormat(
+          "integer overflow in hpack integer decoding: have 0x%08x, "
+          "got byte 0x%02x",
+          varint_out_of_range_.value, varint_out_of_range_.last_byte));
+    case HpackParseStatus::kIllegalTableSizeChange:
+      return absl::InternalError(absl::StrCat(
+          "Attempt to make hpack table ", illegal_table_size_change_.new_size,
+          " bytes when max is ", illegal_table_size_change_.max_size,
+          " bytes"));
+    case HpackParseStatus::kAddBeforeTableSizeUpdated:
+      return absl::InternalError(
+          absl::StrCat("HPACK max table size reduced to ",
+                       illegal_table_size_change_.new_size,
+                       " but not reflected by hpack stream (still at ",
+                       illegal_table_size_change_.max_size, ")"));
+    case HpackParseStatus::kParseHuffFailed:
+      if (!key_.empty()) {
+        return absl::InternalError(
+            absl::StrCat("Failed huffman decoding '", key_, "' metadata"));
+      } else {
+        return absl::InternalError(
+            absl::StrCat("Failed huffman decoding metadata"));
+      }
+      break;
+    case HpackParseStatus::kTooManyDynamicTableSizeChanges:
+      return absl::InternalError(
+          "More than two max table size changes in a single frame");
+    case HpackParseStatus::kMaliciousVarintEncoding:
+      return absl::InternalError(
+          "Malicious varint encoding detected in HPACK stream");
+    case HpackParseStatus::kInvalidHpackIndex:
+      return absl::InternalError(absl::StrFormat(
+          "Invalid HPACK index received (%d)", invalid_hpack_index_));
+    case HpackParseStatus::kIllegalHpackOpCode:
+      return absl::InternalError("Illegal hpack op code");
+  }
+  GPR_UNREACHABLE_CODE(return absl::UnknownError("Should never reach here"));
+}
+
+}  // namespace grpc_core