grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/handshaker/security/secure_endpoint.cc

@@ -38,7 +38,6 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
@@ -59,6 +58,7 @@
 #include "src/core/tsi/transport_security_grpc.h"
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/string.h"
@@ -102,6 +102,7 @@ class FrameProtector : public RefCounted<FrameProtector> {
       write_staging_buffer_ =
           memory_owner_.MakeSlice(MemoryRequest(STAGING_BUFFER_SIZE));
     }
+    is_zero_copy_protector_ = (zero_copy_protector_ != nullptr);
   }
 
   ~FrameProtector() override {
@@ -289,6 +290,8 @@ class FrameProtector : public RefCounted<FrameProtector> {
     grpc_slice_buffer_reset_and_unref(read_buffer_);
   }
 
+  bool IsZeroCopyProtector() const { return is_zero_copy_protector_; }
+
   bool MaybeCompleteReadImmediately() {
     GRPC_TRACE_LOG(secure_endpoint, INFO)
         << "MaybeCompleteReadImmediately: " << this
@@ -456,6 +459,7 @@ class FrameProtector : public RefCounted<FrameProtector> {
   int min_progress_size_ = 1;
   SliceBuffer protector_staging_buffer_;
   bool shutdown_ = false;
+  bool is_zero_copy_protector_ = false;
 };
 }  // namespace
 }  // namespace grpc_core
@@ -795,9 +799,12 @@ class SecureEndpoint final : public EventEngine::Endpoint {
       if (frame_protector_.MaybeCompleteReadImmediately()) {
         return MaybeFinishReadImmediately();
       }
-      args.set_read_hint_bytes(frame_protector_.min_progress_size());
+      if (frame_protector_.IsZeroCopyProtector()) {
+        args.set_read_hint_bytes(frame_protector_.min_progress_size());
+      }
       bool read_completed_immediately = wrapped_ep_->Read(
           [impl = Ref()](absl::Status status) mutable {
+            grpc_core::ExecCtx exec_ctx;
             FinishAsyncRead(std::move(impl), std::move(status));
           },
           frame_protector_.source_buffer(), std::move(args));
@@ -832,7 +839,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
           // in the FinishAsyncWrites path, and EventEngine insists that one
           // write finishes before a second begins, we should never see a Write
           // call here with a non-null pending_writes_.
-          CHECK(pending_writes_ == nullptr);
+          GRPC_CHECK(pending_writes_ == nullptr);
           pending_writes_ = std::make_unique<SliceBuffer>(std::move(*data));
           frame_protector_.TraceOp("Pending",
                                    pending_writes_->c_slice_buffer());
@@ -844,6 +851,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
           if (!*writing_) {
             writing_ = true;
             event_engine_->Run([impl = Ref()]() mutable {
+              grpc_core::ExecCtx exec_ctx;
               FinishAsyncWrite(std::move(impl));
             });
           }
@@ -917,6 +925,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
       if (grpc_core::IsSecureEndpointOffloadLargeReadsEnabled() &&
           frame_protector_.source_buffer()->Length() > large_read_threshold_) {
         event_engine_->Run([impl = Ref()]() mutable {
+          grpc_core::ExecCtx exec_ctx;
           FinishAsyncRead(std::move(impl), absl::OkStatus());
         });
         return false;
@@ -982,7 +991,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
           grpc_core::ReleasableMutexLock lock(&impl->write_queue_mu_);
           if (impl->pending_writes_ == nullptr) {
             impl->writing_ = false;
-            DCHECK(impl->on_write_ == nullptr);
+            GRPC_DCHECK(impl->on_write_ == nullptr);
             lock.Release();
             return;
           }
@@ -990,7 +999,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
           data = std::move(impl->pending_writes_);
           impl->frame_protector_.TraceOp("data", data->c_slice_buffer());
           args = std::move(impl->last_write_args_);
-          DCHECK(impl->on_write_ != nullptr);
+          GRPC_DCHECK(impl->on_write_ != nullptr);
         }
         impl->event_engine_->Run(
             [on_write = std::move(impl->on_write_)]() mutable {
@@ -1022,6 +1031,7 @@ class SecureEndpoint final : public EventEngine::Endpoint {
         // immediately, in which case we'll loop.
         const bool write_finished_immediately = impl->wrapped_ep_->Write(
             [impl](absl::Status status) mutable {
+              grpc_core::ExecCtx exec_ctx;
               // Async completion path: if we completed successfully then loop
               // back into FinishAsyncWrite to see if there's more writing to
               // do.
@@ -1075,7 +1085,7 @@ grpc_core::OrphanablePtr<grpc_endpoint> grpc_secure_endpoint_create(
     std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
         event_engine_endpoint = grpc_event_engine::experimental::
             grpc_take_wrapped_event_engine_endpoint(to_wrap.release());
-    CHECK(event_engine_endpoint != nullptr);
+    GRPC_CHECK(event_engine_endpoint != nullptr);
     if (grpc_core::IsPipelinedReadSecureEndpointEnabled()) {
       return grpc_pipelined_secure_endpoint_create(
           protector, zero_copy_protector, std::move(event_engine_endpoint),

data/src/core/handshaker/security/security_handshaker.cc

@@ -37,7 +37,6 @@
 
 #include "absl/base/attributes.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
@@ -61,6 +60,7 @@
 #include "src/core/transport/auth_context.h"
 #include "src/core/tsi/transport_security_grpc.h"
 #include "src/core/util/debug_location.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/unique_type_name.h"
@@ -345,7 +345,7 @@ grpc_error_handle SecurityHandshaker::OnHandshakeNextDoneLocked(
   }
   // Read more if we need to.
   if (result == TSI_INCOMPLETE_DATA) {
-    CHECK_EQ(bytes_to_send_size, 0u);
+    GRPC_CHECK_EQ(bytes_to_send_size, 0u);
     grpc_endpoint_read(
         args_->endpoint.get(), args_->read_buffer.c_slice_buffer(),
         NewClosure([self = RefAsSubclass<SecurityHandshaker>()](
@@ -365,7 +365,7 @@ grpc_error_handle SecurityHandshaker::OnHandshakeNextDoneLocked(
   }
   // Update handshaker result.
   if (handshaker_result != nullptr) {
-    CHECK_EQ(handshaker_result_, nullptr);
+    GRPC_CHECK_EQ(handshaker_result_, nullptr);
     handshaker_result_ = handshaker_result;
   }
   if (bytes_to_send_size > 0) {

data/src/core/handshaker/tcp_connect/tcp_connect_handshaker.cc

@@ -29,7 +29,6 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "src/core/config/core_configuration.h"
@@ -50,6 +49,7 @@
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"
 #include "src/core/util/debug_location.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/uri.h"
@@ -185,7 +185,7 @@ void TCPConnectHandshaker::Connected(void* arg, grpc_error_handle error) {
       }
       return;
     }
-    CHECK_NE(self->endpoint_to_destroy_, nullptr);
+    GRPC_CHECK_NE(self->endpoint_to_destroy_, nullptr);
     self->args_->endpoint.reset(self->endpoint_to_destroy_);
     self->endpoint_to_destroy_ = nullptr;
     if (self->bind_endpoint_to_pollset_) {

data/src/core/lib/channel/channel_stack.cc

@@ -24,13 +24,14 @@
 #include <memory>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "src/core/channelz/property_list.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/util/alloc.h"
+#include "src/core/util/grpc_check.h"
 
 using grpc_event_engine::experimental::EventEngine;
 
@@ -65,7 +66,7 @@ size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
                                                sizeof(grpc_channel_element));
   size_t i;
 
-  CHECK((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0)
+  GRPC_CHECK((GPR_MAX_ALIGNMENT & (GPR_MAX_ALIGNMENT - 1)) == 0)
       << "GPR_MAX_ALIGNMENT must be a power of two";
 
   // add the size for each filter
@@ -165,9 +166,9 @@ grpc_error_handle grpc_channel_stack_init(
     call_size += GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_call_data);
   }
 
-  CHECK(user_data > (char*)stack);
-  CHECK((uintptr_t)(user_data - (char*)stack) ==
-        grpc_channel_stack_size(filters, filter_count));
+  GRPC_CHECK(user_data > (char*)stack);
+  GRPC_CHECK((uintptr_t)(user_data - (char*)stack) ==
+             grpc_channel_stack_size(filters, filter_count));
 
   stack->call_stack_size = call_size;
   stack->channelz_data_source.Init(
@@ -180,6 +181,8 @@ void grpc_channel_stack::ChannelStackDataSource::AddData(
   grpc_channel_stack* channel_stack = reinterpret_cast<grpc_channel_stack*>(
       reinterpret_cast<char*>(this) -
       offsetof(grpc_channel_stack, channelz_data_source));
+  grpc_core::CoreConfiguration::Get().channel_init().AddData(
+      sink, channel_stack->type);
   sink.AddData(
       "channel_stack",
       grpc_core::channelz::PropertyList()

data/src/core/lib/channel/channel_stack.h

@@ -57,6 +57,7 @@
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/call_final_info.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/metrics.h"
@@ -187,6 +188,8 @@ struct grpc_channel_stack {
   // should look like and this can go.
   grpc_core::ManualConstructor<std::function<void()>> on_destroy;
 
+  grpc_channel_stack_type type;
+
   class ChannelStackDataSource final : public grpc_core::channelz::DataSource {
    public:
     explicit ChannelStackDataSource(

data/src/core/lib/channel/channel_stack_builder_impl.cc

@@ -65,6 +65,7 @@ ChannelStackBuilderImpl::Build() {
   // allocate memory
   auto* channel_stack =
       static_cast<grpc_channel_stack*>(gpr_zalloc(channel_stack_size));
+  channel_stack->type = this->channel_stack_type();
 
   // and initialize it
   grpc_error_handle error = grpc_channel_stack_init(

data/src/core/lib/channel/connected_channel.cc

@@ -31,7 +31,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "src/core/call/call_finalization.h"
@@ -71,6 +70,7 @@
 #include "src/core/lib/transport/transport.h"
 #include "src/core/util/alloc.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
@@ -220,7 +220,7 @@ static void connected_channel_destroy_call_elem(
 static grpc_error_handle connected_channel_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* cd = static_cast<channel_data*>(elem->channel_data);
-  CHECK(args->is_last);
+  GRPC_CHECK(args->is_last);
   cd->transport = args->channel_args.GetObject<grpc_core::Transport>();
   return absl::OkStatus();
 }