grpc 1.58.0 → 1.60.0

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

@@ -25,6 +25,8 @@
 #include <map>
 #include <string>
 
+#include "absl/base/thread_annotations.h"
+
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -90,8 +92,8 @@ class ChannelzRegistry {
 
   // protects members
   Mutex mu_;
-  std::map<intptr_t, BaseNode*> node_map_;
-  intptr_t uuid_generator_ = 0;
+  std::map<intptr_t, BaseNode*> node_map_ ABSL_GUARDED_BY(mu_);
+  intptr_t uuid_generator_ ABSL_GUARDED_BY(mu_) = 0;
 };
 
 }  // namespace channelz

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

@@ -23,7 +23,6 @@
 #include <inttypes.h>
 
 #include <functional>
-#include <initializer_list>
 #include <memory>
 #include <string>
 #include <type_traits>
@@ -32,7 +31,6 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
-#include "absl/types/variant.h"
 
 #include <grpc/grpc.h>
 #include <grpc/status.h>
@@ -43,6 +41,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gpr/alloc.h"
@@ -80,11 +79,9 @@
 #include "src/core/lib/transport/error_utils.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"
 
 typedef struct connected_channel_channel_data {
-  grpc_transport* transport;
+  grpc_core::Transport* transport;
 } channel_data;
 
 struct callback_state {
@@ -183,15 +180,15 @@ static void connected_channel_start_transport_stream_op_batch(
     callback_state* state = get_state_for_batch(calld, batch);
     intercept_callback(calld, state, false, "on_complete", &batch->on_complete);
   }
-  grpc_transport_perform_stream_op(
-      chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld), batch);
+  chand->transport->filter_stack_transport()->PerformStreamOp(
+      TRANSPORT_STREAM_FROM_CALL_DATA(calld), batch);
   GRPC_CALL_COMBINER_STOP(calld->call_combiner, "passed batch to transport");
 }
 
 static void connected_channel_start_transport_op(grpc_channel_element* elem,
                                                  grpc_transport_op* op) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  grpc_transport_perform_op(chand->transport, op);
+  chand->transport->PerformOp(op);
 }
 
 // Constructor for call_data
@@ -200,19 +197,18 @@ static grpc_error_handle connected_channel_init_call_elem(
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   calld->call_combiner = args->call_combiner;
-  int r = grpc_transport_init_stream(
-      chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld),
-      &args->call_stack->refcount, args->server_transport_data, args->arena);
-  return r == 0 ? absl::OkStatus()
-                : GRPC_ERROR_CREATE("transport stream initialization failed");
+  chand->transport->filter_stack_transport()->InitStream(
+      TRANSPORT_STREAM_FROM_CALL_DATA(calld), &args->call_stack->refcount,
+      args->server_transport_data, args->arena);
+  return absl::OkStatus();
 }
 
 static void set_pollset_or_pollset_set(grpc_call_element* elem,
                                        grpc_polling_entity* pollent) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  grpc_transport_set_pops(chand->transport,
-                          TRANSPORT_STREAM_FROM_CALL_DATA(calld), pollent);
+  chand->transport->SetPollingEntity(TRANSPORT_STREAM_FROM_CALL_DATA(calld),
+                                     pollent);
 }
 
 // Destructor for call_data
@@ -221,9 +217,8 @@ static void connected_channel_destroy_call_elem(
     grpc_closure* then_schedule_closure) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
-  grpc_transport_destroy_stream(chand->transport,
-                                TRANSPORT_STREAM_FROM_CALL_DATA(calld),
-                                then_schedule_closure);
+  chand->transport->filter_stack_transport()->DestroyStream(
+      TRANSPORT_STREAM_FROM_CALL_DATA(calld), then_schedule_closure);
 }
 
 // Constructor for channel_data
@@ -231,7 +226,7 @@ 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);
   GPR_ASSERT(args->is_last);
-  cd->transport = args->channel_args.GetObject<grpc_transport>();
+  cd->transport = args->channel_args.GetObject<grpc_core::Transport>();
   return absl::OkStatus();
 }
 
@@ -239,7 +234,7 @@ static grpc_error_handle connected_channel_init_channel_elem(
 static void connected_channel_destroy_channel_elem(grpc_channel_element* elem) {
   channel_data* cd = static_cast<channel_data*>(elem->channel_data);
   if (cd->transport) {
-    grpc_transport_destroy(cd->transport);
+    cd->transport->Orphan();
   }
 }
 
@@ -255,7 +250,7 @@ namespace {
     defined(GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL)
 class ConnectedChannelStream : public Orphanable {
  public:
-  explicit ConnectedChannelStream(grpc_transport* transport)
+  explicit ConnectedChannelStream(Transport* transport)
       : transport_(transport), stream_(nullptr, StreamDeleter(this)) {
     GRPC_STREAM_REF_INIT(
         &stream_refcount_, 1,
@@ -265,7 +260,7 @@ class ConnectedChannelStream : public Orphanable {
         this, "ConnectedChannelStream");
   }
 
-  grpc_transport* transport() { return transport_; }
+  Transport* transport() { return transport_; }
   grpc_closure* stream_destroyed_closure() { return &stream_destroyed_; }
 
   BatchBuilder::Target batch_target() {
@@ -338,8 +333,8 @@ class ConnectedChannelStream : public Orphanable {
     explicit StreamDeleter(ConnectedChannelStream* impl) : impl_(impl) {}
     void operator()(grpc_stream* stream) const {
       if (stream == nullptr) return;
-      grpc_transport_destroy_stream(impl_->transport(), stream,
-                                    impl_->stream_destroyed_closure());
+      impl_->transport()->filter_stack_transport()->DestroyStream(
+          stream, impl_->stream_destroyed_closure());
     }
 
    private:
@@ -359,7 +354,7 @@ class ConnectedChannelStream : public Orphanable {
     }
   }
 
-  grpc_transport* const transport_;
+  Transport* const transport_;
   RefCountedPtr<CallContext> const call_context_{
       GetContext<CallContext>()->Ref()};
   grpc_closure stream_destroyed_ =
@@ -437,22 +432,22 @@ auto ConnectedChannelStream::SendMessages(
         // defined(GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL)
 
 #ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_CLIENT_CALL
-ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(
-    grpc_transport* transport, CallArgs call_args, NextPromiseFactory) {
+ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(Transport* transport,
+                                                         CallArgs call_args,
+                                                         NextPromiseFactory) {
   OrphanablePtr<ConnectedChannelStream> stream(
       GetContext<Arena>()->New<ConnectedChannelStream>(transport));
-  stream->SetStream(static_cast<grpc_stream*>(
-      GetContext<Arena>()->Alloc(transport->vtable->sizeof_stream)));
-  grpc_transport_init_stream(transport, stream->stream(),
-                             stream->stream_refcount(), nullptr,
-                             GetContext<Arena>());
+  stream->SetStream(static_cast<grpc_stream*>(GetContext<Arena>()->Alloc(
+      transport->filter_stack_transport()->SizeOfStream())));
+  transport->filter_stack_transport()->InitStream(stream->stream(),
+                                                  stream->stream_refcount(),
+                                                  nullptr, GetContext<Arena>());
   auto* party = static_cast<Party*>(Activity::current());
-  party->Spawn(
-      "set_polling_entity", call_args.polling_entity->Wait(),
-      [transport,
-       stream = stream->InternalRef()](grpc_polling_entity polling_entity) {
-        grpc_transport_set_pops(transport, stream->stream(), &polling_entity);
-      });
+  party->Spawn("set_polling_entity", call_args.polling_entity->Wait(),
+               [transport, stream = stream->InternalRef()](
+                   grpc_polling_entity polling_entity) {
+                 transport->SetPollingEntity(stream->stream(), &polling_entity);
+               });
   // Start a loop to send messages from client_to_server_messages to the
   // transport. When the pipe closes and the loop completes, send a trailing
   // metadata batch to close the stream.
@@ -548,7 +543,7 @@ ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(
         }
         if (!done_recv_messages) {
           auto p = recv_messages();
-          if (auto* r = p.value_if_ready()) {
+          if (p.ready()) {
             // NOTE: ignore errors here, they'll be collected in the
             // recv_trailing_metadata.
             done_recv_messages = true;
@@ -574,15 +569,14 @@ ArenaPromise<ServerMetadataHandle> MakeClientCallPromise(
 
 #ifdef GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
 ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
-    grpc_transport* transport, CallArgs,
-    NextPromiseFactory next_promise_factory) {
+    Transport* transport, CallArgs, NextPromiseFactory next_promise_factory) {
   OrphanablePtr<ConnectedChannelStream> stream(
       GetContext<Arena>()->New<ConnectedChannelStream>(transport));
 
-  stream->SetStream(static_cast<grpc_stream*>(
-      GetContext<Arena>()->Alloc(transport->vtable->sizeof_stream)));
-  grpc_transport_init_stream(
-      transport, stream->stream(), stream->stream_refcount(),
+  stream->SetStream(static_cast<grpc_stream*>(GetContext<Arena>()->Alloc(
+      transport->filter_stack_transport()->SizeOfStream())));
+  transport->filter_stack_transport()->InitStream(
+      stream->stream(), stream->stream_refcount(),
       GetContext<CallContext>()->server_call_context()->server_stream_data(),
       GetContext<Arena>());
   auto* party = static_cast<Party*>(Activity::current());
@@ -601,12 +595,11 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
   GetContext<CallFinalization>()->Add(
       [call_data](const grpc_call_final_info*) { call_data->~CallData(); });
 
-  party->Spawn(
-      "set_polling_entity", call_data->polling_entity_latch.Wait(),
-      [transport,
-       stream = stream->InternalRef()](grpc_polling_entity polling_entity) {
-        grpc_transport_set_pops(transport, stream->stream(), &polling_entity);
-      });
+  party->Spawn("set_polling_entity", call_data->polling_entity_latch.Wait(),
+               [transport, stream = stream->InternalRef()](
+                   grpc_polling_entity polling_entity) {
+                 transport->SetPollingEntity(stream->stream(), &polling_entity);
+               });
 
   auto server_to_client_empty =
       call_data->server_to_client.receiver.AwaitEmpty();
@@ -847,7 +840,7 @@ ArenaPromise<ServerMetadataHandle> MakeServerCallPromise(
 #endif
 
 template <ArenaPromise<ServerMetadataHandle> (*make_call_promise)(
-    grpc_transport*, CallArgs, NextPromiseFactory)>
+    Transport*, CallArgs, NextPromiseFactory)>
 grpc_channel_filter MakeConnectedFilter() {
   // Create a vtable that contains both the legacy call methods (for filter
   // stack based calls) and the new promise based method for creating
@@ -857,7 +850,7 @@ grpc_channel_filter MakeConnectedFilter() {
   // call be promise based.
   auto make_call_wrapper = +[](grpc_channel_element* elem, CallArgs call_args,
                                NextPromiseFactory next) {
-    grpc_transport* transport =
+    Transport* transport =
         static_cast<channel_data*>(elem->channel_data)->transport;
     return make_call_promise(transport, std::move(call_args), std::move(next));
   };
@@ -877,8 +870,10 @@ grpc_channel_filter MakeConnectedFilter() {
         // do this, and I'm not sure what that is yet. This is only "safe"
         // because call stacks place no additional data after the last call
         // element, and the last call element MUST be the connected channel.
-        channel_stack->call_stack_size += grpc_transport_stream_size(
-            static_cast<channel_data*>(elem->channel_data)->transport);
+        channel_stack->call_stack_size +=
+            static_cast<channel_data*>(elem->channel_data)
+                ->transport->filter_stack_transport()
+                ->SizeOfStream();
       },
       connected_channel_destroy_channel_elem,
       connected_channel_get_channel_info,
@@ -887,8 +882,8 @@ grpc_channel_filter MakeConnectedFilter() {
 }
 
 ArenaPromise<ServerMetadataHandle> MakeTransportCallPromise(
-    grpc_transport* transport, CallArgs call_args, NextPromiseFactory) {
-  return transport->vtable->make_call_promise(transport, std::move(call_args));
+    Transport* transport, CallArgs call_args, NextPromiseFactory) {
+  return transport->client_transport()->MakeCallPromise(std::move(call_args));
 }
 
 const grpc_channel_filter kPromiseBasedTransportFilter =
@@ -910,31 +905,49 @@ const grpc_channel_filter kServerEmulatedFilter =
     MakeConnectedFilter<nullptr>();
 #endif
 
+bool TransportSupportsPromiseBasedCalls(const ChannelArgs& args) {
+  auto* transport = args.GetObject<Transport>();
+  return transport->client_transport() != nullptr;
+}
+
 }  // namespace
-}  // namespace grpc_core
 
-bool grpc_add_connected_filter(grpc_core::ChannelStackBuilder* builder) {
-  grpc_transport* t = builder->transport();
-  GPR_ASSERT(t != nullptr);
-  // Choose the right vtable for the connected filter.
+void RegisterConnectedChannel(CoreConfiguration::Builder* builder) {
   // We can't know promise based call or not here (that decision needs the
   // collaboration of all of the filters on the channel, and we don't want
   // ordering constraints on when we add filters).
   // We can know if this results in a promise based call how we'll create
   // our promise (if indeed we can), and so that is the choice made here.
-  if (t->vtable->make_call_promise != nullptr) {
-    // Option 1, and our ideal: the transport supports promise based calls,
-    // and so we simply use the transport directly.
-    builder->AppendFilter(&grpc_core::kPromiseBasedTransportFilter);
-  } else if (grpc_channel_stack_type_is_client(builder->channel_stack_type())) {
-    // Option 2: the transport does not support promise based calls, but
-    // we're on the client and so we have an implementation that we can use
-    // to convert to batches.
-    builder->AppendFilter(&grpc_core::kClientEmulatedFilter);
-  } else {
-    // Option 3: the transport does not support promise based calls, and
-    // we're on the server so we use the server filter.
-    builder->AppendFilter(&grpc_core::kServerEmulatedFilter);
-  }
-  return true;
+
+  // Option 1, and our ideal: the transport supports promise based calls,
+  // and so we simply use the transport directly.
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL, &kPromiseBasedTransportFilter)
+      .Terminal()
+      .If(TransportSupportsPromiseBasedCalls);
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL,
+                       &kPromiseBasedTransportFilter)
+      .Terminal()
+      .If(TransportSupportsPromiseBasedCalls);
+  builder->channel_init()
+      ->RegisterFilter(GRPC_SERVER_CHANNEL, &kPromiseBasedTransportFilter)
+      .Terminal()
+      .If(TransportSupportsPromiseBasedCalls);
+
+  // Option 2: the transport does not support promise based calls.
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL, &kClientEmulatedFilter)
+      .Terminal()
+      .IfNot(TransportSupportsPromiseBasedCalls);
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL, &kClientEmulatedFilter)
+      .Terminal()
+      .IfNot(TransportSupportsPromiseBasedCalls);
+  builder->channel_init()
+      ->RegisterFilter(GRPC_SERVER_CHANNEL, &kServerEmulatedFilter)
+      .Terminal()
+      .IfNot(TransportSupportsPromiseBasedCalls);
 }
+
+}  // namespace grpc_core

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

@@ -56,6 +56,9 @@ typedef enum {
   /// the server.
   GRPC_CONTEXT_BACKEND_METRIC_PROVIDER,
 
+  /// Special Google context
+  GRPC_CONTEXT_GOOGLE,
+
   GRPC_CONTEXT_COUNT
 } grpc_context_index;
 

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

@@ -17,7 +17,6 @@
 #include "src/core/lib/channel/promise_based_filter.h"
 
 #include <algorithm>
-#include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>
@@ -721,7 +720,7 @@ void BaseCallData::ReceiveMessage::OnComplete(absl::Status status) {
       Crash(absl::StrFormat("ILLEGAL STATE: %s", StateString(state_)));
     case State::kForwardedBatchNoPipe:
       state_ = State::kBatchCompletedNoPipe;
-      return;
+      break;
     case State::kForwardedBatch:
       state_ = State::kBatchCompleted;
       break;
@@ -784,6 +783,8 @@ void BaseCallData::ReceiveMessage::Done(const ServerMetadata& metadata,
       }
     } break;
     case State::kBatchCompletedNoPipe:
+      state_ = State::kBatchCompletedButCancelledNoPipe;
+      break;
     case State::kBatchCompletedButCancelled:
     case State::kBatchCompletedButCancelledNoPipe:
       Crash(absl::StrFormat("ILLEGAL STATE: %s", StateString(state_)));
@@ -1313,10 +1314,13 @@ ClientCallData::ClientCallData(grpc_call_element* elem,
 }
 
 ClientCallData::~ClientCallData() {
+  ScopedActivity scoped_activity(this);
   GPR_ASSERT(poll_ctx_ == nullptr);
   if (recv_initial_metadata_ != nullptr) {
     recv_initial_metadata_->~RecvInitialMetadata();
   }
+  initial_metadata_outstanding_token_ =
+      ClientInitialMetadataOutstandingToken::Empty();
 }
 
 std::string ClientCallData::DebugTag() const {
@@ -2047,7 +2051,8 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
                !batch->recv_initial_metadata && !batch->recv_message &&
                !batch->recv_trailing_metadata);
     PollContext poll_ctx(this, &flusher);
-    Completed(batch->payload->cancel_stream.cancel_error, &flusher);
+    Completed(batch->payload->cancel_stream.cancel_error,
+              batch->payload->cancel_stream.tarpit, &flusher);
     if (is_last()) {
       batch.CompleteWith(&flusher);
     } else {
@@ -2166,7 +2171,8 @@ void ServerCallData::StartBatch(grpc_transport_stream_op_batch* b) {
 }
 
 // Handle cancellation.
-void ServerCallData::Completed(grpc_error_handle error, Flusher* flusher) {
+void ServerCallData::Completed(grpc_error_handle error,
+                               bool tarpit_cancellation, Flusher* flusher) {
   if (grpc_trace_channel.enabled()) {
     gpr_log(
         GPR_DEBUG,
@@ -2196,6 +2202,7 @@ void ServerCallData::Completed(grpc_error_handle error, Flusher* flusher) {
             }));
         batch->cancel_stream = true;
         batch->payload->cancel_stream.cancel_error = error;
+        batch->payload->cancel_stream.tarpit = tarpit_cancellation;
         flusher->Resume(batch);
       }
       break;
@@ -2331,7 +2338,8 @@ void ServerCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
   }
   Flusher flusher(this);
   PollContext poll_ctx(this, &flusher);
-  Completed(error, &flusher);
+  Completed(error, recv_trailing_metadata_->get(GrpcTarPit()).has_value(),
+            &flusher);
   flusher.AddClosure(original_recv_trailing_metadata_ready_, std::move(error),
                      "continue recv trailing");
 }
@@ -2551,7 +2559,8 @@ void ServerCallData::WakeInsideCombiner(Flusher* flusher) {
           break;
         case SendTrailingState::kInitial: {
           GPR_ASSERT(*md->get_pointer(GrpcStatusMetadata()) != GRPC_STATUS_OK);
-          Completed(StatusFromMetadata(*md), flusher);
+          Completed(StatusFromMetadata(*md), md->get(GrpcTarPit()).has_value(),
+                    flusher);
         } break;
         case SendTrailingState::kCancelled:
           // Nothing to do.

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

@@ -25,7 +25,6 @@
 #include <stdlib.h>
 
 #include <atomic>
-#include <initializer_list>
 #include <memory>
 #include <new>
 #include <string>
@@ -739,7 +738,8 @@ class ServerCallData : public BaseCallData {
   struct SendInitialMetadata;
 
   // Shut things down when the call completes.
-  void Completed(grpc_error_handle error, Flusher* flusher);
+  void Completed(grpc_error_handle error, bool tarpit_cancellation,
+                 Flusher* flusher);
   // Construct a promise that will "call" the next filter.
   // Effectively:
   //   - put the modified initial metadata into the batch being sent up.

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

@@ -27,7 +27,6 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -36,8 +35,6 @@
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/map.h"
 #include "src/core/lib/promise/pipe.h"
-#include "src/core/lib/promise/poll.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/transport.h"
 
@@ -99,12 +96,8 @@ ArenaPromise<ServerMetadataHandle> ServerCallTracerFilter::MakeCallPromise(
 }  // namespace
 
 void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder) {
-  builder->channel_init()->RegisterStage(
-      GRPC_SERVER_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](ChannelStackBuilder* builder) {
-        builder->AppendFilter(&ServerCallTracerFilter::kFilter);
-        return true;
-      });
+  builder->channel_init()->RegisterFilter(GRPC_SERVER_CHANNEL,
+                                          &ServerCallTracerFilter::kFilter);
 }
 
 }  // namespace grpc_core

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

@@ -22,7 +22,6 @@
 
 #include <string.h>
 
-#include <algorithm>
 #include <vector>
 
 #include "absl/strings/str_cat.h"

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

@@ -0,0 +1,140 @@
+//
+//
+// 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_LIB_CHANNEL_TCP_TRACER_H
+#define GRPC_SRC_CORE_LIB_CHANNEL_TCP_TRACER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <string>
+
+#include "absl/time/time.h"
+#include "absl/types/optional.h"
+
+namespace grpc_core {
+
+// Interface for TCP tracer implementations. Created by CallTracerInterface.
+class TcpTracerInterface {
+ public:
+  enum class Type {
+    kUnknown = 0,
+    // When the sendmsg system call or its variants returned for the traced byte
+    // offset.
+    kSendMsg,
+    // When the traced byte offset is enqueued in kernel schedulers (aka,
+    // qdiscs). There can be multiple schedulers.
+    kScheduled,
+    // When the traced byte offset is handed over to the NIC.
+    kSent,
+    // When the acknowledgement for the traced byte offset was received.
+    kAcked,
+    // When the connection is closed. This is not associated with a byte offset.
+    kClosed,
+  };
+
+  struct ConnectionMetrics {
+    // Congestion control name.
+    std::string congestion_ctrl;
+    // Delivery rate in Bps.
+    absl::optional<uint64_t> delivery_rate;
+    // Total bytes retransmitted so far.
+    absl::optional<uint64_t> data_retx;
+    // Total bytes sent so far.
+    absl::optional<uint64_t> data_sent;
+    // Total packets lost so far.
+    // Includes lost or spuriously retransmitted packets.
+    absl::optional<uint32_t> packet_retx;
+    // Total packets spuriously retransmitted so far.
+    absl::optional<uint32_t> packet_spurious_retx;
+    // Total packets sent so far.
+    absl::optional<uint32_t> packet_sent;
+    // Total packets delivered so far.
+    absl::optional<uint32_t> packet_delivered;
+    // Total packets delivered so far with ECE marked.
+    // This metric is smaller than or equal to packet_delivered.
+    absl::optional<uint32_t> packet_delivered_ce;
+    // Total bytes in write queue but not sent.
+    absl::optional<uint64_t> data_notsent;
+    // Minimum RTT observed in usec.
+    absl::optional<uint32_t> min_rtt;
+    // Smoothed RTT in usec
+    absl::optional<uint32_t> srtt;
+    // TTL or hop limit of a packet received
+    // Only available with ACKED timestamps.
+    absl::optional<uint32_t> ttl;
+    // Represents the number of recurring retransmissions of
+    // the first sequence that is not acknowledged yet.
+    absl::optional<uint32_t> recurring_retrans;
+    // Network RTT using hardware timestamps (in usec).
+    // A value of -1 indicates that net_rtt could not be measured.
+    absl::optional<int32_t> net_rtt_usec;
+    // Timeout-triggered rehash attempts.
+    absl::optional<uint32_t> timeout_rehash;
+    // Rehash due to ECN congestion.
+    absl::optional<uint32_t> ecn_rehash;
+    // Earliest departure time (CLOCK_MONOTONIC).
+    // Only available with SCHEDULED and SENT timestamps.
+    absl::optional<uint64_t> edt;
+    // If the delivery rate is limited by the application, this is set to
+    // true.
+    absl::optional<bool> is_delivery_rate_app_limited;
+    // Pacing rate of the connection in Bps.
+    absl::optional<uint64_t> pacing_rate;
+    // Send congestion window in packets.
+    absl::optional<uint32_t> congestion_window;
+    // Maximum degree of reordering (i.e., maximum number of packets reodered)
+    // on the connection.
+    absl::optional<uint32_t> reordering;
+    // Cumulative duration (in usec) that the transport protocol
+    // was busy sending time.
+    absl::optional<uint64_t> busy_usec;
+    // Cumulative duration (in usec) that the transport protocol
+    // was limited by the receive window size.
+    absl::optional<uint64_t> rwnd_limited_usec;
+    // Cumulative duration (in usec) that the transport protocol
+    // was limited by the send buffer size.
+    absl::optional<uint64_t> sndbuf_limited_usec;
+    // Slow start size threshold in packets.
+    // Set to TCP_INFINITE_SSTHRESH when still in slow start.
+    absl::optional<uint32_t> snd_ssthresh;
+    // The extra time it takes for the receiver to generate the
+    // acknowledgement after receiving the last packet. This metric is not
+    // cumulative. Only available with ACKED timestamps.
+    absl::optional<uint32_t> time_to_ack_usec;
+    // Last socket error code. Only populated for CLOSED timestamps.
+    absl::optional<uint32_t> socket_errno;
+    // Peer's receive window after scaling (tcpi_snd_wnd).
+    // Only available with SENDMSG timestamps.
+    absl::optional<uint32_t> peer_rwnd;
+    // Receive queue drops.
+    absl::optional<uint32_t> rcvq_drops;
+    // The NIC Rx delay reported by the remote host.
+    absl::optional<uint32_t> nic_rx_delay_usec;
+  };
+
+  virtual ~TcpTracerInterface() = default;
+  virtual void RecordEvent(Type type, absl::Time time, size_t byte_offset,
+                           absl::optional<ConnectionMetrics> metrics) = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_CHANNEL_TCP_TRACER_H

data/src/core/lib/compression/compression_internal.cc

@@ -22,6 +22,8 @@
 
 #include <stdlib.h>
 
+#include <string>
+
 #include "absl/container/inlined_vector.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_format.h"