grpc 1.51.0 → 1.52.0

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

@@ -1,24 +1,24 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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 <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/grpc_types.h>
 
 #include "src/core/lib/gprpp/global_config_generic.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -56,6 +56,7 @@
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/buffer_list.h"
@@ -364,7 +365,7 @@ class TcpZerocopySendCtx {
       // state was CHECK and is_in_write is false. This means that after the
       // previous sendmsg returned and set is_in_write to false, it did
       // not update the z-copy change from CHECK to OPEN.
-      GPR_ASSERT(false && "OMem state error!");
+      Crash("OMem state error!");
     }
   }
 
@@ -478,8 +479,8 @@ struct grpc_tcp {
   grpc_endpoint base;
   grpc_fd* em_fd;
   int fd;
-  /* Used by the endpoint read function to distinguish the very first read call
-   * from the rest */
+  // Used by the endpoint read function to distinguish the very first read call
+  // from the rest
   bool is_first_read;
   bool has_posted_reclaimer ABSL_GUARDED_BY(read_mu) = false;
   double target_length;
@@ -491,16 +492,16 @@ struct grpc_tcp {
   int max_read_chunk_size;
   int set_rcvlowat = 0;
 
-  /* garbage after the last read */
+  // garbage after the last read
   grpc_slice_buffer last_read_buffer;
 
   grpc_core::Mutex read_mu;
   grpc_slice_buffer* incoming_buffer ABSL_GUARDED_BY(read_mu) = nullptr;
-  int inq;          /* bytes pending on the socket from the last read. */
-  bool inq_capable; /* cache whether kernel supports inq */
+  int inq;           // bytes pending on the socket from the last read.
+  bool inq_capable;  // cache whether kernel supports inq
 
   grpc_slice_buffer* outgoing_buffer;
-  /* byte within outgoing_buffer->slices[0] to write next */
+  // byte within outgoing_buffer->slices[0] to write next
   size_t outgoing_byte_idx;
 
   grpc_closure* read_cb;
@@ -518,33 +519,33 @@ struct grpc_tcp {
   grpc_core::MemoryOwner memory_owner;
   grpc_core::MemoryAllocator::Reservation self_reservation;
 
-  grpc_core::TracedBufferList tb_list; /* List of traced buffers */
-
-  /* grpc_endpoint_write takes an argument which if non-null means that the
-   * transport layer wants the TCP layer to collect timestamps for this write.
-   * This arg is forwarded to the timestamps callback function when the ACK
-   * timestamp is received from the kernel. This arg is a (void *) which allows
-   * users of this API to pass in a pointer to any kind of structure. This
-   * structure could actually be a tag or any book-keeping object that the user
-   * can use to distinguish between different traced writes. The only
-   * requirement from the TCP endpoint layer is that this arg should be non-null
-   * if the user wants timestamps for the write. */
+  grpc_core::TracedBufferList tb_list;  // List of traced buffers
+
+  // grpc_endpoint_write takes an argument which if non-null means that the
+  // transport layer wants the TCP layer to collect timestamps for this write.
+  // This arg is forwarded to the timestamps callback function when the ACK
+  // timestamp is received from the kernel. This arg is a (void *) which allows
+  // users of this API to pass in a pointer to any kind of structure. This
+  // structure could actually be a tag or any book-keeping object that the user
+  // can use to distinguish between different traced writes. The only
+  // requirement from the TCP endpoint layer is that this arg should be non-null
+  // if the user wants timestamps for the write.
   void* outgoing_buffer_arg;
-  /* A counter which starts at 0. It is initialized the first time the socket
-   * options for collecting timestamps are set, and is incremented with each
-   * byte sent. */
+  // A counter which starts at 0. It is initialized the first time the socket
+  // options for collecting timestamps are set, and is incremented with each
+  // byte sent.
   int bytes_counter;
-  bool socket_ts_enabled; /* True if timestamping options are set on the socket
-                           */
-  bool ts_capable;        /* Cache whether we can set timestamping options */
-  gpr_atm stop_error_notification; /* Set to 1 if we do not want to be notified
-                                      on errors anymore */
+  bool socket_ts_enabled;  // True if timestamping options are set on the socket
+                           //
+  bool ts_capable;         // Cache whether we can set timestamping options
+  gpr_atm stop_error_notification;  // Set to 1 if we do not want to be notified
+                                    // on errors anymore
   TcpZerocopySendCtx tcp_zerocopy_send_ctx;
   TcpZerocopySendRecord* current_zerocopy_send = nullptr;
 
-  int min_progress_size; /* A hint from upper layers specifying the minimum
-                            number of bytes that need to be read to make
-                            meaningful progress */
+  int min_progress_size;  // A hint from upper layers specifying the minimum
+                          // number of bytes that need to be read to make
+                          // meaningful progress
 };
 
 struct backup_poller {
@@ -590,7 +591,7 @@ static void run_poller(void* bp, grpc_error_handle /*error_ignored*/) {
       grpc_pollset_work(BACKUP_POLLER_POLLSET(p), nullptr, deadline));
   gpr_mu_unlock(p->pollset_mu);
   g_backup_poller_mu->Lock();
-  /* last "uncovered" notification is the ref that keeps us polling */
+  // last "uncovered" notification is the ref that keeps us polling
   if (g_uncovered_notifications_pending == 1) {
     GPR_ASSERT(g_backup_poller == p);
     g_backup_poller = nullptr;
@@ -696,9 +697,9 @@ static void add_to_estimate(grpc_tcp* tcp, size_t bytes) {
 }
 
 static void finish_estimate(grpc_tcp* tcp) {
-  /* If we read >80% of the target buffer in one read loop, increase the size
-     of the target buffer to either the amount read, or twice its previous
-     value */
+  // If we read >80% of the target buffer in one read loop, increase the size
+  // of the target buffer to either the amount read, or twice its previous
+  // value
   if (tcp->bytes_read_this_round > tcp->target_length * 0.8) {
     tcp->target_length =
         std::max(2 * tcp->target_length, tcp->bytes_read_this_round);
@@ -715,8 +716,8 @@ static grpc_error_handle tcp_annotate_error(grpc_error_handle src_error,
       grpc_error_set_int(
           grpc_error_set_int(src_error, grpc_core::StatusIntProperty::kFd,
                              tcp->fd),
-          /* All tcp errors are marked with UNAVAILABLE so that application may
-           * choose to retry. */
+          // All tcp errors are marked with UNAVAILABLE so that application may
+          // choose to retry.
           grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE),
       grpc_core::StatusStrProperty::kTargetAddress, tcp->peer_string);
 }
@@ -866,7 +867,7 @@ static void update_rcvlowat(grpc_tcp* tcp)
   tcp->set_rcvlowat = remaining;
 }
 
-/* Returns true if data available to read or error other than EAGAIN. */
+// Returns true if data available to read or error other than EAGAIN.
 #define MAX_READ_IOVEC 64
 static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
     ABSL_EXCLUSIVE_LOCKS_REQUIRED(tcp->read_mu) {
@@ -884,7 +885,7 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
       CMSG_SPACE(sizeof(grpc_core::scm_timestamping)) + CMSG_SPACE(sizeof(int));
 #else
   constexpr size_t cmsg_alloc_space = 24 /* CMSG_SPACE(sizeof(int)) */;
-#endif /* GRPC_LINUX_ERRQUEUE */
+#endif  // GRPC_LINUX_ERRQUEUE
   char cmsgbuf[cmsg_alloc_space];
   for (size_t i = 0; i < iov_len; i++) {
     iov[i].iov_base = GRPC_SLICE_START_PTR(tcp->incoming_buffer->slices[i]);
@@ -895,9 +896,9 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
   GPR_DEBUG_ASSERT(tcp->min_progress_size > 0);
 
   do {
-    /* Assume there is something on the queue. If we receive TCP_INQ from
-     * kernel, we will update this value, otherwise, we have to assume there is
-     * always something to read until we get EAGAIN. */
+    // Assume there is something on the queue. If we receive TCP_INQ from
+    // kernel, we will update this value, otherwise, we have to assume there is
+    // always something to read until we get EAGAIN.
     tcp->inq = 1;
 
     msg.msg_name = nullptr;
@@ -924,8 +925,8 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
     } while (read_bytes < 0 && errno == EINTR);
 
     if (read_bytes < 0 && errno == EAGAIN) {
-      /* NB: After calling call_read_cb a parallel call of the read handler may
-       * be running. */
+      // NB: After calling call_read_cb a parallel call of the read handler may
+      // be running.
       if (total_read_bytes > 0) {
         break;
       }
@@ -934,15 +935,15 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
       return false;
     }
 
-    /* We have read something in previous reads. We need to deliver those
-     * bytes to the upper layer. */
+    // We have read something in previous reads. We need to deliver those
+    // bytes to the upper layer.
     if (read_bytes <= 0 && total_read_bytes >= 1) {
       tcp->inq = 1;
       break;
     }
 
     if (read_bytes <= 0) {
-      /* 0 read size ==> end of stream */
+      // 0 read size ==> end of stream
       grpc_slice_buffer_reset_and_unref(tcp->incoming_buffer);
       if (read_bytes == 0) {
         *error = tcp_annotate_error(absl::InternalError("Socket closed"), tcp);
@@ -972,15 +973,15 @@ static bool tcp_do_read(grpc_tcp* tcp, grpc_error_handle* error)
         }
       }
     }
-#endif /* GRPC_HAVE_TCP_INQ */
+#endif  // GRPC_HAVE_TCP_INQ
 
     total_read_bytes += read_bytes;
     if (tcp->inq == 0 || total_read_bytes == tcp->incoming_buffer->length) {
       break;
     }
 
-    /* We had a partial read, and still have space to read more data.
-     * So, adjust IOVs and try to read more. */
+    // We had a partial read, and still have space to read more data.
+    // So, adjust IOVs and try to read more.
     size_t remaining = read_bytes;
     size_t j = 0;
     for (size_t i = 0; i < iov_len; i++) {
@@ -1117,7 +1118,7 @@ static void tcp_handle_read(void* arg /* grpc_tcp */, grpc_error_handle error) {
   if (GPR_LIKELY(error.ok())) {
     maybe_make_read_slices(tcp);
     if (!tcp_do_read(tcp, &tcp_read_error)) {
-      /* We've consumed the edge, request a new one */
+      // We've consumed the edge, request a new one
       update_rcvlowat(tcp);
       tcp->read_mu.Unlock();
       notify_on_read(tcp);
@@ -1144,62 +1145,63 @@ static void tcp_read(grpc_endpoint* ep, grpc_slice_buffer* incoming_buffer,
   tcp->read_cb = cb;
   tcp->read_mu.Lock();
   tcp->incoming_buffer = incoming_buffer;
-  tcp->min_progress_size =
-      grpc_core::IsTcpFrameSizeTuningEnabled() ? min_progress_size : 1;
+  tcp->min_progress_size = grpc_core::IsTcpFrameSizeTuningEnabled()
+                               ? std::max(min_progress_size, 1)
+                               : 1;
   grpc_slice_buffer_reset_and_unref(incoming_buffer);
   grpc_slice_buffer_swap(incoming_buffer, &tcp->last_read_buffer);
   TCP_REF(tcp, "read");
   if (tcp->is_first_read) {
     update_rcvlowat(tcp);
     tcp->read_mu.Unlock();
-    /* Endpoint read called for the very first time. Register read callback with
-     * the polling engine */
+    // Endpoint read called for the very first time. Register read callback with
+    // the polling engine
     tcp->is_first_read = false;
     notify_on_read(tcp);
   } else if (!urgent && tcp->inq == 0) {
     update_rcvlowat(tcp);
     tcp->read_mu.Unlock();
-    /* Upper layer asked to read more but we know there is no pending data
-     * to read from previous reads. So, wait for POLLIN.
-     */
+    // Upper layer asked to read more but we know there is no pending data
+    // to read from previous reads. So, wait for POLLIN.
+    //
     notify_on_read(tcp);
   } else {
     tcp->read_mu.Unlock();
-    /* Not the first time. We may or may not have more bytes available. In any
-     * case call tcp->read_done_closure (i.e tcp_handle_read()) which does the
-     * right thing (i.e calls tcp_do_read() which either reads the available
-     * bytes or calls notify_on_read() to be notified when new bytes become
-     * available */
+    // Not the first time. We may or may not have more bytes available. In any
+    // case call tcp->read_done_closure (i.e tcp_handle_read()) which does the
+    // right thing (i.e calls tcp_do_read() which either reads the available
+    // bytes or calls notify_on_read() to be notified when new bytes become
+    // available
     grpc_core::Closure::Run(DEBUG_LOCATION, &tcp->read_done_closure,
                             absl::OkStatus());
   }
 }
 
-/* A wrapper around sendmsg. It sends \a msg over \a fd and returns the number
- * of bytes sent. */
+// A wrapper around sendmsg. It sends \a msg over \a fd and returns the number
+// of bytes sent.
 ssize_t tcp_send(int fd, const struct msghdr* msg, int* saved_errno,
                  int additional_flags = 0) {
   ssize_t sent_length;
   do {
-    /* TODO(klempner): Cork if this is a partial write */
+    // TODO(klempner): Cork if this is a partial write
     grpc_core::global_stats().IncrementSyscallWrite();
     sent_length = sendmsg(fd, msg, SENDMSG_FLAGS | additional_flags);
   } while (sent_length < 0 && (*saved_errno = errno) == EINTR);
   return sent_length;
 }
 
-/** This is to be called if outgoing_buffer_arg is not null. On linux platforms,
- * this will call sendmsg with socket options set to collect timestamps inside
- * the kernel. On return, sent_length is set to the return value of the sendmsg
- * call. Returns false if setting the socket options failed. This is not
- * implemented for non-linux platforms currently, and crashes out.
- */
+/// This is to be called if outgoing_buffer_arg is not null. On linux platforms,
+/// this will call sendmsg with socket options set to collect timestamps inside
+/// the kernel. On return, sent_length is set to the return value of the sendmsg
+/// call. Returns false if setting the socket options failed. This is not
+/// implemented for non-linux platforms currently, and crashes out.
+///
 static bool tcp_write_with_timestamps(grpc_tcp* tcp, struct msghdr* msg,
                                       size_t sending_length,
                                       ssize_t* sent_length, int* saved_errno,
                                       int additional_flags = 0);
 
-/** The callback function to be invoked when we get an error on the socket. */
+/// The callback function to be invoked when we get an error on the socket.
 static void tcp_handle_error(void* arg /* grpc_tcp */, grpc_error_handle error);
 
 static TcpZerocopySendRecord* tcp_get_send_zerocopy_record(
@@ -1254,7 +1256,7 @@ static bool tcp_write_with_timestamps(grpc_tcp* tcp, struct msghdr* msg,
     tcp->bytes_counter = -1;
     tcp->socket_ts_enabled = true;
   }
-  /* Set control message to indicate that you want timestamps. */
+  // Set control message to indicate that you want timestamps.
   union {
     char cmsg_buf[CMSG_SPACE(sizeof(uint32_t))];
     struct cmsghdr align;
@@ -1268,10 +1270,10 @@ static bool tcp_write_with_timestamps(grpc_tcp* tcp, struct msghdr* msg,
   msg->msg_control = u.cmsg_buf;
   msg->msg_controllen = CMSG_SPACE(sizeof(uint32_t));
 
-  /* If there was an error on sendmsg the logic in tcp_flush will handle it. */
+  // If there was an error on sendmsg the logic in tcp_flush will handle it.
   ssize_t length = tcp_send(tcp->fd, msg, saved_errno, additional_flags);
   *sent_length = length;
-  /* Only save timestamps if all the bytes were taken by sendmsg. */
+  // Only save timestamps if all the bytes were taken by sendmsg.
   if (sending_length == static_cast<size_t>(length)) {
     tcp->tb_list.AddNewEntry(static_cast<uint32_t>(tcp->bytes_counter + length),
                              tcp->fd, tcp->outgoing_buffer_arg);
@@ -1320,13 +1322,13 @@ static bool CmsgIsZeroCopy(const cmsghdr& cmsg) {
   return serr->ee_errno == 0 && serr->ee_origin == SO_EE_ORIGIN_ZEROCOPY;
 }
 
-/** Reads \a cmsg to derive timestamps from the control messages. If a valid
- * timestamp is found, the traced buffer list is updated with this timestamp.
- * The caller of this function should be looping on the control messages found
- * in \a msg. \a cmsg should point to the control message that the caller wants
- * processed.
- * On return, a pointer to a control message is returned. On the next iteration,
- * CMSG_NXTHDR(msg, ret_val) should be passed as \a cmsg. */
+/// Reads \a cmsg to derive timestamps from the control messages. If a valid
+/// timestamp is found, the traced buffer list is updated with this timestamp.
+/// The caller of this function should be looping on the control messages found
+/// in \a msg. \a cmsg should point to the control message that the caller wants
+/// processed.
+/// On return, a pointer to a control message is returned. On the next
+/// iteration, CMSG_NXTHDR(msg, ret_val) should be passed as \a cmsg.
 struct cmsghdr* process_timestamp(grpc_tcp* tcp, msghdr* msg,
                                   struct cmsghdr* cmsg) {
   auto next_cmsg = CMSG_NXTHDR(msg, cmsg);
@@ -1338,7 +1340,7 @@ struct cmsghdr* process_timestamp(grpc_tcp* tcp, msghdr* msg,
     return cmsg;
   }
 
-  /* Check if next_cmsg is an OPT_STATS msg */
+  // Check if next_cmsg is an OPT_STATS msg
   if (next_cmsg->cmsg_level == SOL_SOCKET &&
       next_cmsg->cmsg_type == SCM_TIMESTAMPING_OPT_STATS) {
     opt_stats = next_cmsg;
@@ -1372,9 +1374,9 @@ struct cmsghdr* process_timestamp(grpc_tcp* tcp, msghdr* msg,
   return next_cmsg;
 }
 
-/** For linux platforms, reads the socket's error queue and processes error
- * messages from the queue.
- */
+/// For linux platforms, reads the socket's error queue and processes error
+/// messages from the queue.
+///
 static bool process_errors(grpc_tcp* tcp) {
   bool processed_err = false;
   struct iovec iov;
@@ -1386,13 +1388,13 @@ static bool process_errors(grpc_tcp* tcp) {
   msg.msg_iov = &iov;
   msg.msg_iovlen = 0;
   msg.msg_flags = 0;
-  /* Allocate enough space so we don't need to keep increasing this as size
-   * of OPT_STATS increase */
+  // Allocate enough space so we don't need to keep increasing this as size
+  // of OPT_STATS increase
   constexpr size_t cmsg_alloc_space =
       CMSG_SPACE(sizeof(grpc_core::scm_timestamping)) +
       CMSG_SPACE(sizeof(sock_extended_err) + sizeof(sockaddr_in)) +
       CMSG_SPACE(32 * NLA_ALIGN(NLA_HDRLEN + sizeof(uint64_t)));
-  /* Allocate aligned space for cmsgs received along with timestamps */
+  // Allocate aligned space for cmsgs received along with timestamps
   union {
     char rbuf[cmsg_alloc_space];
     struct cmsghdr align;
@@ -1407,7 +1409,7 @@ static bool process_errors(grpc_tcp* tcp) {
     } while (r < 0 && saved_errno == EINTR);
 
     if (r == -1 && saved_errno == EAGAIN) {
-      return processed_err; /* No more errors to process */
+      return processed_err;  // No more errors to process
     }
     if (r == -1) {
       return processed_err;
@@ -1417,7 +1419,7 @@ static bool process_errors(grpc_tcp* tcp) {
     }
 
     if (msg.msg_controllen == 0) {
-      /* There was no control message found. It was probably spurious. */
+      // There was no control message found. It was probably spurious.
       return processed_err;
     }
     bool seen = false;
@@ -1433,8 +1435,8 @@ static bool process_errors(grpc_tcp* tcp) {
         seen = true;
         processed_err = true;
       } else {
-        /* Got a control message that is not a timestamp or zerocopy. Don't know
-         * how to handle this. */
+        // Got a control message that is not a timestamp or zerocopy. Don't know
+        // how to handle this.
         if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace)) {
           gpr_log(GPR_INFO,
                   "unknown control message cmsg_level:%d cmsg_type:%d",
@@ -1459,17 +1461,17 @@ static void tcp_handle_error(void* arg /* grpc_tcp */,
 
   if (!error.ok() ||
       static_cast<bool>(gpr_atm_acq_load(&tcp->stop_error_notification))) {
-    /* We aren't going to register to hear on error anymore, so it is safe to
-     * unref. */
+    // We aren't going to register to hear on error anymore, so it is safe to
+    // unref.
     TCP_UNREF(tcp, "error-tracking");
     return;
   }
 
-  /* We are still interested in collecting timestamps, so let's try reading
-   * them. */
+  // We are still interested in collecting timestamps, so let's try reading
+  // them.
   bool processed = process_errors(tcp);
-  /* This might not a timestamps error. Set the read and write closures to be
-   * ready. */
+  // This might not a timestamps error. Set the read and write closures to be
+  // ready.
   if (!processed) {
     grpc_fd_set_readable(tcp->em_fd);
     grpc_fd_set_writable(tcp->em_fd);
@@ -1477,7 +1479,7 @@ static void tcp_handle_error(void* arg /* grpc_tcp */,
   grpc_fd_notify_on_error(tcp->em_fd, &tcp->error_closure);
 }
 
-#else  /* GRPC_LINUX_ERRQUEUE */
+#else   // GRPC_LINUX_ERRQUEUE
 static TcpZerocopySendRecord* tcp_get_send_zerocopy_record(
     grpc_tcp* /*tcp*/, grpc_slice_buffer* /*buf*/) {
   return nullptr;
@@ -1500,10 +1502,10 @@ static void tcp_handle_error(void* /*arg*/ /* grpc_tcp */,
   gpr_log(GPR_ERROR, "Error handling is not supported for this platform");
   GPR_ASSERT(0);
 }
-#endif /* GRPC_LINUX_ERRQUEUE */
+#endif  // GRPC_LINUX_ERRQUEUE
 
-/* If outgoing_buffer_arg is filled, shuts down the list early, so that any
- * release operations needed can be performed on the arg */
+// If outgoing_buffer_arg is filled, shuts down the list early, so that any
+// release operations needed can be performed on the arg
 void tcp_shutdown_buffer_list(grpc_tcp* tcp) {
   if (tcp->outgoing_buffer_arg) {
     tcp->tb_list.Shutdown(tcp->outgoing_buffer_arg,
@@ -1590,8 +1592,8 @@ static bool do_tcp_flush_zerocopy(grpc_tcp* tcp, TcpZerocopySendRecord* record,
       if (!tcp->ts_capable ||
           !tcp_write_with_timestamps(tcp, &msg, sending_length, &sent_length,
                                      &saved_errno, MSG_ZEROCOPY)) {
-        /* We could not set socket options to collect Fathom timestamps.
-         * Fallback on writing without timestamps. */
+        // We could not set socket options to collect Fathom timestamps.
+        // Fallback on writing without timestamps.
         tcp->ts_capable = false;
         tcp_shutdown_buffer_list(tcp);
       } else {
@@ -1702,8 +1704,8 @@ static bool tcp_flush(grpc_tcp* tcp, grpc_error_handle* error) {
       if (!tcp->ts_capable ||
           !tcp_write_with_timestamps(tcp, &msg, sending_length, &sent_length,
                                      &saved_errno)) {
-        /* We could not set socket options to collect Fathom timestamps.
-         * Fallback on writing without timestamps. */
+        // We could not set socket options to collect Fathom timestamps.
+        // Fallback on writing without timestamps.
         tcp->ts_capable = false;
         tcp_shutdown_buffer_list(tcp);
       } else {
@@ -1961,7 +1963,7 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
   tcp->release_fd = nullptr;
   tcp->target_length = static_cast<double>(options.tcp_read_chunk_size);
   tcp->bytes_read_this_round = 0;
-  /* Will be set to false by the very first endpoint read function */
+  // Will be set to false by the very first endpoint read function
   tcp->is_first_read = true;
   tcp->bytes_counter = -1;
   tcp->socket_ts_enabled = false;
@@ -1981,7 +1983,7 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
     }
 #endif
   }
-  /* paired with unref in grpc_tcp_destroy */
+  // paired with unref in grpc_tcp_destroy
   new (&tcp->refcount) grpc_core::RefCount(
       1, GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) ? "tcp" : nullptr);
   gpr_atm_no_barrier_store(&tcp->shutdown_count, 0);
@@ -1999,7 +2001,7 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
                       tcp_drop_uncovered_then_handle_write, tcp,
                       grpc_schedule_on_exec_ctx);
   }
-  /* Always assume there is something on the queue to read. */
+  // Always assume there is something on the queue to read.
   tcp->inq = 1;
 #ifdef GRPC_HAVE_TCP_INQ
   int one = 1;
@@ -2011,12 +2013,12 @@ grpc_endpoint* grpc_tcp_create(grpc_fd* em_fd,
   }
 #else
   tcp->inq_capable = false;
-#endif /* GRPC_HAVE_TCP_INQ */
-  /* Start being notified on errors if event engine can track errors. */
+#endif  // GRPC_HAVE_TCP_INQ
+  // Start being notified on errors if event engine can track errors.
   if (grpc_event_engine_can_track_errors()) {
-    /* Grab a ref to tcp so that we can safely access the tcp struct when
-     * processing errors. We unref when we no longer want to track errors
-     * separately. */
+    // Grab a ref to tcp so that we can safely access the tcp struct when
+    // processing errors. We unref when we no longer want to track errors
+    // separately.
     TCP_REF(tcp, "error-tracking");
     gpr_atm_rel_store(&tcp->stop_error_notification, 0);
     GRPC_CLOSURE_INIT(&tcp->error_closure, tcp_handle_error, tcp,
@@ -2041,7 +2043,7 @@ void grpc_tcp_destroy_and_release_fd(grpc_endpoint* ep, int* fd,
   tcp->release_fd_cb = done;
   grpc_slice_buffer_reset_and_unref(&tcp->last_read_buffer);
   if (grpc_event_engine_can_track_errors()) {
-    /* Stop errors notification. */
+    // Stop errors notification.
     ZerocopyDisableAndWaitForRemaining(tcp);
     gpr_atm_no_barrier_store(&tcp->stop_error_notification, true);
     grpc_fd_set_error(tcp->em_fd);
@@ -2056,4 +2058,4 @@ void grpc_tcp_posix_shutdown() {
   g_backup_poller_mu = nullptr;
 }
 
-#endif /* GRPC_POSIX_SOCKET_TCP */
+#endif  // GRPC_POSIX_SOCKET_TCP

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

@@ -1,33 +1,33 @@
-/*
- *
- * Copyright 2015 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.
- *
- */
+//
+//
+// Copyright 2015 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_CORE_LIB_IOMGR_TCP_POSIX_H
 #define GRPC_CORE_LIB_IOMGR_TCP_POSIX_H
-/*
-   Low level TCP "bottom half" implementation, for use by transports built on
-   top of a TCP connection.
+//
+// Low level TCP "bottom half" implementation, for use by transports built on
+// top of a TCP connection.
 
-   Note that this file does not (yet) include APIs for creating the socket in
-   the first place.
+// Note that this file does not (yet) include APIs for creating the socket in
+// the first place.
 
-   All calls passing slice transfer ownership of a slice refcount unless
-   otherwise specified.
-*/
+// All calls passing slice transfer ownership of a slice refcount unless
+// otherwise specified.
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -62,6 +62,6 @@ void grpc_tcp_posix_init();
 
 void grpc_tcp_posix_shutdown();
 
-#endif /* GRPC_POSIX_SOCKET_TCP */
+#endif  // GRPC_POSIX_SOCKET_TCP
 
-#endif /* GRPC_CORE_LIB_IOMGR_TCP_POSIX_H */
+#endif  // GRPC_CORE_LIB_IOMGR_TCP_POSIX_H