grpc 1.18.0 → 1.22.0

data/src/core/lib/http/httpcli_security_connector.cc

@@ -59,7 +59,6 @@ class grpc_httpcli_ssl_channel_security_connector final
   tsi_result InitHandshakerFactory(const char* pem_root_certs,
                                    const tsi_ssl_root_certs_store* root_store) {
     tsi_ssl_client_handshaker_options options;
-    memset(&options, 0, sizeof(options));
     options.pem_root_certs = pem_root_certs;
     options.root_store = root_store;
     return tsi_create_ssl_client_handshaker_factory_with_options(
@@ -67,7 +66,7 @@ class grpc_httpcli_ssl_channel_security_connector final
   }
 
   void add_handshakers(grpc_pollset_set* interested_parties,
-                       grpc_handshake_manager* handshake_mgr) override {
+                       grpc_core::HandshakeManager* handshake_mgr) override {
     tsi_handshaker* handshaker = nullptr;
     if (handshaker_factory_ != nullptr) {
       tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
@@ -77,8 +76,7 @@ class grpc_httpcli_ssl_channel_security_connector final
                 tsi_result_to_string(result));
       }
     }
-    grpc_handshake_manager_add(
-        handshake_mgr, grpc_security_handshaker_create(handshaker, this));
+    handshake_mgr->Add(grpc_core::SecurityHandshakerCreate(handshaker, this));
   }
 
   tsi_ssl_client_handshaker_factory* handshaker_factory() const {
@@ -155,11 +153,11 @@ httpcli_ssl_channel_security_connector_create(
 typedef struct {
   void (*func)(void* arg, grpc_endpoint* endpoint);
   void* arg;
-  grpc_handshake_manager* handshake_mgr;
+  grpc_core::RefCountedPtr<grpc_core::HandshakeManager> handshake_mgr;
 } on_done_closure;
 
 static void on_handshake_done(void* arg, grpc_error* error) {
-  grpc_handshaker_args* args = static_cast<grpc_handshaker_args*>(arg);
+  auto* args = static_cast<grpc_core::HandshakerArgs*>(arg);
   on_done_closure* c = static_cast<on_done_closure*>(args->user_data);
   if (error != GRPC_ERROR_NONE) {
     const char* msg = grpc_error_string(error);
@@ -172,14 +170,13 @@ static void on_handshake_done(void* arg, grpc_error* error) {
     gpr_free(args->read_buffer);
     c->func(c->arg, args->endpoint);
   }
-  grpc_handshake_manager_destroy(c->handshake_mgr);
-  gpr_free(c);
+  grpc_core::Delete<on_done_closure>(c);
 }
 
 static void ssl_handshake(void* arg, grpc_endpoint* tcp, const char* host,
                           grpc_millis deadline,
                           void (*on_done)(void* arg, grpc_endpoint* endpoint)) {
-  on_done_closure* c = static_cast<on_done_closure*>(gpr_malloc(sizeof(*c)));
+  auto* c = grpc_core::New<on_done_closure>();
   const char* pem_root_certs =
       grpc_core::DefaultSslRootStore::GetPemRootCerts();
   const tsi_ssl_root_certs_store* root_store =
@@ -198,12 +195,13 @@ static void ssl_handshake(void* arg, grpc_endpoint* tcp, const char* host,
   GPR_ASSERT(sc != nullptr);
   grpc_arg channel_arg = grpc_security_connector_to_arg(sc.get());
   grpc_channel_args args = {1, &channel_arg};
-  c->handshake_mgr = grpc_handshake_manager_create();
-  grpc_handshakers_add(HANDSHAKER_CLIENT, &args,
-                       nullptr /* interested_parties */, c->handshake_mgr);
-  grpc_handshake_manager_do_handshake(
-      c->handshake_mgr, tcp, nullptr /* channel_args */, deadline,
-      nullptr /* acceptor */, on_handshake_done, c /* user_data */);
+  c->handshake_mgr = grpc_core::MakeRefCounted<grpc_core::HandshakeManager>();
+  grpc_core::HandshakerRegistry::AddHandshakers(
+      grpc_core::HANDSHAKER_CLIENT, &args, /*interested_parties=*/nullptr,
+      c->handshake_mgr.get());
+  c->handshake_mgr->DoHandshake(tcp, /*channel_args=*/nullptr, deadline,
+                                /*acceptor=*/nullptr, on_handshake_done,
+                                /*user_data=*/c);
   sc.reset(DEBUG_LOCATION, "httpcli");
 }
 

data/src/core/lib/http/parser.cc

@@ -300,7 +300,7 @@ static grpc_error* addbyte(grpc_http_parser* parser, uint8_t byte,
     case GRPC_HTTP_FIRST_LINE:
     case GRPC_HTTP_HEADERS:
       if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) {
-        if (grpc_http1_trace.enabled())
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_http1_trace))
           gpr_log(GPR_ERROR, "HTTP header max line length (%d) exceeded",
                   GRPC_HTTP_PARSER_MAX_HEADER_LENGTH);
         return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -351,7 +351,8 @@ void grpc_http_response_destroy(grpc_http_response* response) {
   gpr_free(response->hdrs);
 }
 
-grpc_error* grpc_http_parser_parse(grpc_http_parser* parser, grpc_slice slice,
+grpc_error* grpc_http_parser_parse(grpc_http_parser* parser,
+                                   const grpc_slice& slice,
                                    size_t* start_of_body) {
   for (size_t i = 0; i < GRPC_SLICE_LENGTH(slice); i++) {
     bool found_body_start = false;

data/src/core/lib/http/parser.h

@@ -101,7 +101,8 @@ void grpc_http_parser_init(grpc_http_parser* parser, grpc_http_type type,
 void grpc_http_parser_destroy(grpc_http_parser* parser);
 
 /* Sets \a start_of_body to the offset in \a slice of the start of the body. */
-grpc_error* grpc_http_parser_parse(grpc_http_parser* parser, grpc_slice slice,
+grpc_error* grpc_http_parser_parse(grpc_http_parser* parser,
+                                   const grpc_slice& slice,
                                    size_t* start_of_body);
 grpc_error* grpc_http_parser_eof(grpc_http_parser* parser);
 

data/src/core/lib/iomgr/buffer_list.cc

@@ -24,32 +24,13 @@
 #include <grpc/support/log.h>
 
 #ifdef GRPC_LINUX_ERRQUEUE
+#include <netinet/in.h>
+#include <string.h>
 #include <time.h>
 
 #include "src/core/lib/gprpp/memory.h"
 
 namespace grpc_core {
-void TracedBuffer::AddNewEntry(TracedBuffer** head, uint32_t seq_no,
-                               void* arg) {
-  GPR_DEBUG_ASSERT(head != nullptr);
-  TracedBuffer* new_elem = New<TracedBuffer>(seq_no, arg);
-  /* Store the current time as the sendmsg time. */
-  new_elem->ts_.sendmsg_time = gpr_now(GPR_CLOCK_REALTIME);
-  new_elem->ts_.scheduled_time = gpr_inf_past(GPR_CLOCK_REALTIME);
-  new_elem->ts_.sent_time = gpr_inf_past(GPR_CLOCK_REALTIME);
-  new_elem->ts_.acked_time = gpr_inf_past(GPR_CLOCK_REALTIME);
-  if (*head == nullptr) {
-    *head = new_elem;
-    return;
-  }
-  /* Append at the end. */
-  TracedBuffer* ptr = *head;
-  while (ptr->next_ != nullptr) {
-    ptr = ptr->next_;
-  }
-  ptr->next_ = new_elem;
-}
-
 namespace {
 /** Fills gpr_timespec gts based on values from timespec ts */
 void fill_gpr_from_timestamp(gpr_timespec* gts, const struct timespec* ts) {
@@ -68,10 +49,180 @@ void default_timestamps_callback(void* arg, grpc_core::Timestamps* ts,
 void (*timestamps_callback)(void*, grpc_core::Timestamps*,
                             grpc_error* shutdown_err) =
     default_timestamps_callback;
+
+/* Used to extract individual opt stats from cmsg, so as to avoid troubles with
+ * unaligned reads */
+template <typename T>
+T read_unaligned(const void* ptr) {
+  T val;
+  memcpy(&val, ptr, sizeof(val));
+  return val;
+}
+
+/* Extracts opt stats from the tcp_info struct \a info to \a metrics */
+void extract_opt_stats_from_tcp_info(ConnectionMetrics* metrics,
+                                     const grpc_core::tcp_info* info) {
+  if (info == nullptr) {
+    return;
+  }
+  if (info->length > offsetof(grpc_core::tcp_info, tcpi_sndbuf_limited)) {
+    metrics->recurring_retrans.set(info->tcpi_retransmits);
+    metrics->is_delivery_rate_app_limited.set(
+        info->tcpi_delivery_rate_app_limited);
+    metrics->congestion_window.set(info->tcpi_snd_cwnd);
+    metrics->reordering.set(info->tcpi_reordering);
+    metrics->packet_retx.set(info->tcpi_total_retrans);
+    metrics->pacing_rate.set(info->tcpi_pacing_rate);
+    metrics->data_notsent.set(info->tcpi_notsent_bytes);
+    if (info->tcpi_min_rtt != UINT32_MAX) {
+      metrics->min_rtt.set(info->tcpi_min_rtt);
+    }
+    metrics->packet_sent.set(info->tcpi_data_segs_out);
+    metrics->delivery_rate.set(info->tcpi_delivery_rate);
+    metrics->busy_usec.set(info->tcpi_busy_time);
+    metrics->rwnd_limited_usec.set(info->tcpi_rwnd_limited);
+    metrics->sndbuf_limited_usec.set(info->tcpi_sndbuf_limited);
+  }
+  if (info->length > offsetof(grpc_core::tcp_info, tcpi_dsack_dups)) {
+    metrics->data_sent.set(info->tcpi_bytes_sent);
+    metrics->data_retx.set(info->tcpi_bytes_retrans);
+    metrics->packet_spurious_retx.set(info->tcpi_dsack_dups);
+  }
+}
+
+/** Extracts opt stats from the given control message \a opt_stats to the
+ * connection metrics \a metrics */
+void extract_opt_stats_from_cmsg(ConnectionMetrics* metrics,
+                                 const cmsghdr* opt_stats) {
+  if (opt_stats == nullptr) {
+    return;
+  }
+  const auto* data = CMSG_DATA(opt_stats);
+  constexpr int64_t cmsg_hdr_len = CMSG_ALIGN(sizeof(struct cmsghdr));
+  const int64_t len = opt_stats->cmsg_len - cmsg_hdr_len;
+  int64_t offset = 0;
+
+  while (offset < len) {
+    const auto* attr = reinterpret_cast<const nlattr*>(data + offset);
+    const void* val = data + offset + NLA_HDRLEN;
+    switch (attr->nla_type) {
+      case TCP_NLA_BUSY: {
+        metrics->busy_usec.set(read_unaligned<uint64_t>(val));
+        break;
+      }
+      case TCP_NLA_RWND_LIMITED: {
+        metrics->rwnd_limited_usec.set(read_unaligned<uint64_t>(val));
+        break;
+      }
+      case TCP_NLA_SNDBUF_LIMITED: {
+        metrics->sndbuf_limited_usec.set(read_unaligned<uint64_t>(val));
+        break;
+      }
+      case TCP_NLA_PACING_RATE: {
+        metrics->pacing_rate.set(read_unaligned<uint64_t>(val));
+        break;
+      }
+      case TCP_NLA_DELIVERY_RATE: {
+        metrics->delivery_rate.set(read_unaligned<uint64_t>(val));
+        break;
+      }
+      case TCP_NLA_DELIVERY_RATE_APP_LMT: {
+        metrics->is_delivery_rate_app_limited.set(read_unaligned<uint8_t>(val));
+        break;
+      }
+      case TCP_NLA_SND_CWND: {
+        metrics->congestion_window.set(read_unaligned<uint32_t>(val));
+        break;
+      }
+      case TCP_NLA_MIN_RTT: {
+        metrics->min_rtt.set(read_unaligned<uint32_t>(val));
+        break;
+      }
+      case TCP_NLA_SRTT: {
+        metrics->srtt.set(read_unaligned<uint32_t>(val));
+        break;
+      }
+      case TCP_NLA_RECUR_RETRANS: {
+        metrics->recurring_retrans.set(read_unaligned<uint8_t>(val));
+        break;
+      }
+      case TCP_NLA_BYTES_SENT: {
+        metrics->data_sent.set(read_unaligned<uint64_t>(val));
+        break;
+      }
+      case TCP_NLA_DATA_SEGS_OUT: {
+        metrics->packet_sent.set(read_unaligned<uint64_t>(val));
+        break;
+      }
+      case TCP_NLA_TOTAL_RETRANS: {
+        metrics->packet_retx.set(read_unaligned<uint64_t>(val));
+        break;
+      }
+      case TCP_NLA_DELIVERED: {
+        metrics->packet_delivered.set(read_unaligned<uint32_t>(val));
+        break;
+      }
+      case TCP_NLA_DELIVERED_CE: {
+        metrics->packet_delivered_ce.set(read_unaligned<uint32_t>(val));
+        break;
+      }
+      case TCP_NLA_BYTES_RETRANS: {
+        metrics->data_retx.set(read_unaligned<uint64_t>(val));
+        break;
+      }
+      case TCP_NLA_DSACK_DUPS: {
+        metrics->packet_spurious_retx.set(read_unaligned<uint32_t>(val));
+        break;
+      }
+      case TCP_NLA_REORDERING: {
+        metrics->reordering.set(read_unaligned<uint32_t>(val));
+        break;
+      }
+      case TCP_NLA_SND_SSTHRESH: {
+        metrics->snd_ssthresh.set(read_unaligned<uint32_t>(val));
+        break;
+      }
+    }
+    offset += NLA_ALIGN(attr->nla_len);
+  }
+}
+
+static int get_socket_tcp_info(grpc_core::tcp_info* info, int fd) {
+  memset(info, 0, sizeof(*info));
+  info->length = sizeof(*info) - sizeof(socklen_t);
+  return getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &(info->length));
+}
 } /* namespace */
 
+void TracedBuffer::AddNewEntry(TracedBuffer** head, uint32_t seq_no, int fd,
+                               void* arg) {
+  GPR_DEBUG_ASSERT(head != nullptr);
+  TracedBuffer* new_elem = New<TracedBuffer>(seq_no, arg);
+  /* Store the current time as the sendmsg time. */
+  new_elem->ts_.sendmsg_time.time = gpr_now(GPR_CLOCK_REALTIME);
+  new_elem->ts_.scheduled_time.time = gpr_inf_past(GPR_CLOCK_REALTIME);
+  new_elem->ts_.sent_time.time = gpr_inf_past(GPR_CLOCK_REALTIME);
+  new_elem->ts_.acked_time.time = gpr_inf_past(GPR_CLOCK_REALTIME);
+
+  if (get_socket_tcp_info(&new_elem->ts_.info, fd) == 0) {
+    extract_opt_stats_from_tcp_info(&new_elem->ts_.sendmsg_time.metrics,
+                                    &new_elem->ts_.info);
+  }
+  if (*head == nullptr) {
+    *head = new_elem;
+    return;
+  }
+  /* Append at the end. */
+  TracedBuffer* ptr = *head;
+  while (ptr->next_ != nullptr) {
+    ptr = ptr->next_;
+  }
+  ptr->next_ = new_elem;
+}
+
 void TracedBuffer::ProcessTimestamp(TracedBuffer** head,
                                     struct sock_extended_err* serr,
+                                    struct cmsghdr* opt_stats,
                                     struct scm_timestamping* tss) {
   GPR_DEBUG_ASSERT(head != nullptr);
   TracedBuffer* elem = *head;
@@ -82,15 +233,22 @@ void TracedBuffer::ProcessTimestamp(TracedBuffer** head,
     if (serr->ee_data >= elem->seq_no_) {
       switch (serr->ee_info) {
         case SCM_TSTAMP_SCHED:
-          fill_gpr_from_timestamp(&(elem->ts_.scheduled_time), &(tss->ts[0]));
+          fill_gpr_from_timestamp(&(elem->ts_.scheduled_time.time),
+                                  &(tss->ts[0]));
+          extract_opt_stats_from_cmsg(&(elem->ts_.scheduled_time.metrics),
+                                      opt_stats);
           elem = elem->next_;
           break;
         case SCM_TSTAMP_SND:
-          fill_gpr_from_timestamp(&(elem->ts_.sent_time), &(tss->ts[0]));
+          fill_gpr_from_timestamp(&(elem->ts_.sent_time.time), &(tss->ts[0]));
+          extract_opt_stats_from_cmsg(&(elem->ts_.sent_time.metrics),
+                                      opt_stats);
           elem = elem->next_;
           break;
         case SCM_TSTAMP_ACK:
-          fill_gpr_from_timestamp(&(elem->ts_.acked_time), &(tss->ts[0]));
+          fill_gpr_from_timestamp(&(elem->ts_.acked_time.time), &(tss->ts[0]));
+          extract_opt_stats_from_cmsg(&(elem->ts_.acked_time.metrics),
+                                      opt_stats);
           /* Got all timestamps. Do the callback and free this TracedBuffer.
            * The thing below can be passed by value if we don't want the
            * restriction on the lifetime. */

data/src/core/lib/iomgr/buffer_list.h

@@ -26,19 +26,78 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/optional.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
 
 namespace grpc_core {
+
+struct ConnectionMetrics {
+  /* Delivery rate in Bytes/s. */
+  Optional<uint64_t> delivery_rate;
+  /* If the delivery rate is limited by the application, this is set to true. */
+  Optional<bool> is_delivery_rate_app_limited;
+  /* Total packets retransmitted. */
+  Optional<uint32_t> packet_retx;
+  /* Total packets retransmitted spuriously. This metric is smaller than or
+  equal to packet_retx. */
+  Optional<uint32_t> packet_spurious_retx;
+  /* Total packets sent. */
+  Optional<uint32_t> packet_sent;
+  /* Total packets delivered. */
+  Optional<uint32_t> packet_delivered;
+  /* Total packets delivered with ECE marked. This metric is smaller than or
+  equal to packet_delivered. */
+  Optional<uint32_t> packet_delivered_ce;
+  /* Total bytes lost so far. */
+  Optional<uint64_t> data_retx;
+  /* Total bytes sent so far. */
+  Optional<uint64_t> data_sent;
+  /* Total bytes in write queue but not sent. */
+  Optional<uint64_t> data_notsent;
+  /* Pacing rate of the connection in Bps */
+  Optional<uint64_t> pacing_rate;
+  /* Minimum RTT observed in usec. */
+  Optional<uint32_t> min_rtt;
+  /* Smoothed RTT in usec */
+  Optional<uint32_t> srtt;
+  /* Send congestion window. */
+  Optional<uint32_t> congestion_window;
+  /* Slow start threshold in packets. */
+  Optional<uint32_t> snd_ssthresh;
+  /* Maximum degree of reordering (i.e., maximum number of packets reodered)
+   on the connection. */
+  Optional<uint32_t> reordering;
+  /* Represents the number of recurring retransmissions of the first sequence
+  that is not acknowledged yet. */
+  Optional<uint8_t> recurring_retrans;
+  /* The cumulative time (in usec) that the transport protocol was busy
+   sending data. */
+  Optional<uint64_t> busy_usec;
+  /* The cumulative time (in usec) that the transport protocol was limited by
+   the receive window size. */
+  Optional<uint64_t> rwnd_limited_usec;
+  /* The cumulative time (in usec) that the transport protocol was limited by
+   the send buffer size. */
+  Optional<uint64_t> sndbuf_limited_usec;
+};
+
+struct Timestamp {
+  gpr_timespec time;
+  ConnectionMetrics metrics; /* Metrics collected with this timestamp */
+};
+
 struct Timestamps {
-  /* TODO(yashykt): This would also need to store OPTSTAT once support is added
-   */
-  gpr_timespec sendmsg_time;
-  gpr_timespec scheduled_time;
-  gpr_timespec sent_time;
-  gpr_timespec acked_time;
+  Timestamp sendmsg_time;
+  Timestamp scheduled_time;
+  Timestamp sent_time;
+  Timestamp acked_time;
 
   uint32_t byte_offset; /* byte offset relative to the start of the RPC */
+
+#ifdef GRPC_LINUX_ERRQUEUE
+  grpc_core::tcp_info info; /* tcp_info collected on sendmsg */
+#endif                      /* GRPC_LINUX_ERRQUEUE */
 };
 
 /** TracedBuffer is a class to keep track of timestamps for a specific buffer in
@@ -58,13 +117,14 @@ class TracedBuffer {
   /** Add a new entry in the TracedBuffer list pointed to by head. Also saves
    * sendmsg_time with the current timestamp. */
   static void AddNewEntry(grpc_core::TracedBuffer** head, uint32_t seq_no,
-                          void* arg);
+                          int fd, void* arg);
 
   /** Processes a received timestamp based on sock_extended_err and
    * scm_timestamping structures. It will invoke the timestamps callback if the
    * timestamp type is SCM_TSTAMP_ACK. */
   static void ProcessTimestamp(grpc_core::TracedBuffer** head,
                                struct sock_extended_err* serr,
+                               struct cmsghdr* opt_stats,
                                struct scm_timestamping* tss);
 
   /** Cleans the list by calling the callback for each traced buffer in the list
@@ -73,7 +133,7 @@ class TracedBuffer {
                        grpc_error* shutdown_err);
 
  private:
-  GPRC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW
+  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW
 
   TracedBuffer(uint32_t seq_no, void* arg)
       : seq_no_(seq_no), arg_(arg), next_(nullptr) {}
@@ -88,7 +148,9 @@ class TracedBuffer {
  public:
   /* Dummy shutdown function */
   static void Shutdown(grpc_core::TracedBuffer** head, void* remaining,
-                       grpc_error* shutdown_err) {}
+                       grpc_error* shutdown_err) {
+    GRPC_ERROR_UNREF(shutdown_err);
+  }
 };
 #endif /* GRPC_LINUX_ERRQUEUE */
 
@@ -98,6 +160,6 @@ void grpc_tcp_set_write_timestamps_callback(void (*fn)(void*,
                                                        grpc_core::Timestamps*,
                                                        grpc_error* error));
 
-}; /* namespace grpc_core */
+} /* namespace grpc_core */
 
 #endif /* GRPC_CORE_LIB_IOMGR_BUFFER_LIST_H */