grpc 1.50.0 → 1.51.0

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

@@ -22,6 +22,7 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_LINUX_ERRQUEUE
@@ -29,72 +30,70 @@
 #include <string.h>
 #include <time.h>
 
-#include "src/core/lib/gprpp/memory.h"
-
 namespace grpc_core {
 namespace {
-/** Fills gpr_timespec gts based on values from timespec ts */
-void fill_gpr_from_timestamp(gpr_timespec* gts, const struct timespec* ts) {
+// Fills gpr_timespec gts based on values from timespec ts.
+void FillGprFromTimestamp(gpr_timespec* gts, const struct timespec* ts) {
   gts->tv_sec = ts->tv_sec;
   gts->tv_nsec = static_cast<int32_t>(ts->tv_nsec);
   gts->clock_type = GPR_CLOCK_REALTIME;
 }
 
-void default_timestamps_callback(void* /*arg*/, Timestamps* /*ts*/,
-                                 grpc_error_handle /*shudown_err*/) {
+void DefaultTimestampsCallback(void* /*arg*/, Timestamps* /*ts*/,
+                               absl::Status /*shudown_err*/) {
   gpr_log(GPR_DEBUG, "Timestamps callback has not been registered");
 }
 
-/** The saved callback function that will be invoked when we get all the
- * timestamps that we are going to get for a TracedBuffer. */
-void (*timestamps_callback)(void*, Timestamps*,
-                            grpc_error_handle shutdown_err) =
-    default_timestamps_callback;
+// The saved callback function that will be invoked when we get all the
+// timestamps that we are going to get for a TracedBuffer.
+void (*g_timestamps_callback)(void*, Timestamps*,
+                              grpc_error_handle shutdown_err) =
+    DefaultTimestampsCallback;
 
-/* Used to extract individual opt stats from cmsg, so as to avoid troubles with
- * unaligned reads */
+// 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 ReadUnaligned(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 tcp_info* info) {
+// Extracts opt stats from the tcp_info struct \a info to \a metrics
+void ExtractOptStatsFromTcpInfo(ConnectionMetrics* metrics,
+                                const tcp_info* info) {
   if (info == nullptr) {
     return;
   }
   if (info->length > offsetof(tcp_info, tcpi_sndbuf_limited)) {
-    metrics->recurring_retrans.emplace(info->tcpi_retransmits);
-    metrics->is_delivery_rate_app_limited.emplace(
-        info->tcpi_delivery_rate_app_limited);
-    metrics->congestion_window.emplace(info->tcpi_snd_cwnd);
-    metrics->reordering.emplace(info->tcpi_reordering);
-    metrics->packet_retx.emplace(info->tcpi_total_retrans);
-    metrics->pacing_rate.emplace(info->tcpi_pacing_rate);
-    metrics->data_notsent.emplace(info->tcpi_notsent_bytes);
+    metrics->recurring_retrans = info->tcpi_retransmits;
+    metrics->is_delivery_rate_app_limited =
+        info->tcpi_delivery_rate_app_limited;
+    metrics->congestion_window = info->tcpi_snd_cwnd;
+    metrics->reordering = info->tcpi_reordering;
+    metrics->packet_retx = info->tcpi_total_retrans;
+    metrics->pacing_rate = info->tcpi_pacing_rate;
+    metrics->data_notsent = info->tcpi_notsent_bytes;
     if (info->tcpi_min_rtt != UINT32_MAX) {
-      metrics->min_rtt.emplace(info->tcpi_min_rtt);
+      metrics->min_rtt = info->tcpi_min_rtt;
     }
-    metrics->packet_sent.emplace(info->tcpi_data_segs_out);
-    metrics->delivery_rate.emplace(info->tcpi_delivery_rate);
-    metrics->busy_usec.emplace(info->tcpi_busy_time);
-    metrics->rwnd_limited_usec.emplace(info->tcpi_rwnd_limited);
-    metrics->sndbuf_limited_usec.emplace(info->tcpi_sndbuf_limited);
+    metrics->packet_sent = info->tcpi_data_segs_out;
+    metrics->delivery_rate = info->tcpi_delivery_rate;
+    metrics->busy_usec = info->tcpi_busy_time;
+    metrics->rwnd_limited_usec = info->tcpi_rwnd_limited;
+    metrics->sndbuf_limited_usec = info->tcpi_sndbuf_limited;
   }
   if (info->length > offsetof(tcp_info, tcpi_dsack_dups)) {
-    metrics->data_sent.emplace(info->tcpi_bytes_sent);
-    metrics->data_retx.emplace(info->tcpi_bytes_retrans);
-    metrics->packet_spurious_retx.emplace(info->tcpi_dsack_dups);
+    metrics->data_sent = info->tcpi_bytes_sent;
+    metrics->data_retx = info->tcpi_bytes_retrans;
+    metrics->packet_spurious_retx = 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) {
+// Extracts opt stats from the given control message \a opt_stats to the
+// connection metrics \a metrics.
+void ExtractOptStatsFromCmsg(ConnectionMetrics* metrics,
+                             const cmsghdr* opt_stats) {
   if (opt_stats == nullptr) {
     return;
   }
@@ -108,80 +107,79 @@ void extract_opt_stats_from_cmsg(ConnectionMetrics* metrics,
     const void* val = data + offset + NLA_HDRLEN;
     switch (attr->nla_type) {
       case TCP_NLA_BUSY: {
-        metrics->busy_usec.emplace(read_unaligned<uint64_t>(val));
+        metrics->busy_usec = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_RWND_LIMITED: {
-        metrics->rwnd_limited_usec.emplace(read_unaligned<uint64_t>(val));
+        metrics->rwnd_limited_usec = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_SNDBUF_LIMITED: {
-        metrics->sndbuf_limited_usec.emplace(read_unaligned<uint64_t>(val));
+        metrics->sndbuf_limited_usec = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_PACING_RATE: {
-        metrics->pacing_rate.emplace(read_unaligned<uint64_t>(val));
+        metrics->pacing_rate = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_DELIVERY_RATE: {
-        metrics->delivery_rate.emplace(read_unaligned<uint64_t>(val));
+        metrics->delivery_rate = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_DELIVERY_RATE_APP_LMT: {
-        metrics->is_delivery_rate_app_limited.emplace(
-            read_unaligned<uint8_t>(val));
+        metrics->is_delivery_rate_app_limited = ReadUnaligned<uint8_t>(val);
         break;
       }
       case TCP_NLA_SND_CWND: {
-        metrics->congestion_window.emplace(read_unaligned<uint32_t>(val));
+        metrics->congestion_window = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_MIN_RTT: {
-        metrics->min_rtt.emplace(read_unaligned<uint32_t>(val));
+        metrics->min_rtt = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_SRTT: {
-        metrics->srtt.emplace(read_unaligned<uint32_t>(val));
+        metrics->srtt = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_RECUR_RETRANS: {
-        metrics->recurring_retrans.emplace(read_unaligned<uint8_t>(val));
+        metrics->recurring_retrans = ReadUnaligned<uint8_t>(val);
         break;
       }
       case TCP_NLA_BYTES_SENT: {
-        metrics->data_sent.emplace(read_unaligned<uint64_t>(val));
+        metrics->data_sent = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_DATA_SEGS_OUT: {
-        metrics->packet_sent.emplace(read_unaligned<uint64_t>(val));
+        metrics->packet_sent = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_TOTAL_RETRANS: {
-        metrics->packet_retx.emplace(read_unaligned<uint64_t>(val));
+        metrics->packet_retx = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_DELIVERED: {
-        metrics->packet_delivered.emplace(read_unaligned<uint32_t>(val));
+        metrics->packet_delivered = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_DELIVERED_CE: {
-        metrics->packet_delivered_ce.emplace(read_unaligned<uint32_t>(val));
+        metrics->packet_delivered_ce = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_BYTES_RETRANS: {
-        metrics->data_retx.emplace(read_unaligned<uint64_t>(val));
+        metrics->data_retx = ReadUnaligned<uint64_t>(val);
         break;
       }
       case TCP_NLA_DSACK_DUPS: {
-        metrics->packet_spurious_retx.emplace(read_unaligned<uint32_t>(val));
+        metrics->packet_spurious_retx = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_REORDERING: {
-        metrics->reordering.emplace(read_unaligned<uint32_t>(val));
+        metrics->reordering = ReadUnaligned<uint32_t>(val);
         break;
       }
       case TCP_NLA_SND_SSTHRESH: {
-        metrics->snd_ssthresh.emplace(read_unaligned<uint32_t>(val));
+        metrics->snd_ssthresh = ReadUnaligned<uint32_t>(val);
         break;
       }
     }
@@ -189,75 +187,68 @@ void extract_opt_stats_from_cmsg(ConnectionMetrics* metrics,
   }
 }
 
-int get_socket_tcp_info(tcp_info* info, int fd) {
+int GetSocketTcpInfo(struct tcp_info* info, int fd) {
   memset(info, 0, sizeof(*info));
   info->length = offsetof(tcp_info, length);
   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);
+}  // namespace.
+
+void TracedBufferList::AddNewEntry(int32_t seq_no, int fd, void* arg) {
   TracedBuffer* new_elem = new TracedBuffer(seq_no, arg);
-  /* Store the current time as the sendmsg time. */
+  // 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 (GetSocketTcpInfo(&(new_elem->ts_.info), fd) == 0) {
+    ExtractOptStatsFromTcpInfo(&(new_elem->ts_.sendmsg_time.metrics),
+                               &(new_elem->ts_.info));
   }
-  if (*head == nullptr) {
-    *head = new_elem;
-    return;
+  MutexLock lock(&mu_);
+  if (!head_) {
+    head_ = tail_ = new_elem;
+  } else {
+    tail_->next_ = new_elem;
+    tail_ = new_elem;
   }
-  /* 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;
-  TracedBuffer* next = nullptr;
+void TracedBufferList::ProcessTimestamp(struct sock_extended_err* serr,
+                                        struct cmsghdr* opt_stats,
+                                        struct scm_timestamping* tss) {
+  MutexLock lock(&mu_);
+  TracedBuffer* elem = head_;
   while (elem != nullptr) {
-    /* The byte number refers to the sequence number of the last byte which this
-     * timestamp relates to. */
+    // The byte number refers to the sequence number of the last byte which this
+    // timestamp relates to.
     if (serr->ee_data >= elem->seq_no_) {
       switch (serr->ee_info) {
         case SCM_TSTAMP_SCHED:
-          fill_gpr_from_timestamp(&(elem->ts_.scheduled_time.time),
-                                  &(tss->ts[0]));
-          extract_opt_stats_from_cmsg(&(elem->ts_.scheduled_time.metrics),
-                                      opt_stats);
+          FillGprFromTimestamp(&(elem->ts_.scheduled_time.time), &(tss->ts[0]));
+          ExtractOptStatsFromCmsg(&(elem->ts_.scheduled_time.metrics),
+                                  opt_stats);
           elem = elem->next_;
           break;
         case SCM_TSTAMP_SND:
-          fill_gpr_from_timestamp(&(elem->ts_.sent_time.time), &(tss->ts[0]));
-          extract_opt_stats_from_cmsg(&(elem->ts_.sent_time.metrics),
-                                      opt_stats);
+          FillGprFromTimestamp(&(elem->ts_.sent_time.time), &(tss->ts[0]));
+          ExtractOptStatsFromCmsg(&(elem->ts_.sent_time.metrics), opt_stats);
           elem = elem->next_;
           break;
         case SCM_TSTAMP_ACK:
-          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. */
-          timestamps_callback(elem->arg_, &(elem->ts_), GRPC_ERROR_NONE);
-          next = elem->next_;
-          delete static_cast<TracedBuffer*>(elem);
-          *head = elem = next;
+          FillGprFromTimestamp(&(elem->ts_.acked_time.time), &(tss->ts[0]));
+          ExtractOptStatsFromCmsg(&(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.
+          g_timestamps_callback(elem->arg_, &(elem->ts_), absl::OkStatus());
+          // Safe to update head_ to elem->next_ because the list is ordered by
+          // seq_no. Thus if elem is to be deleted, it has to be the first
+          // element in the list.
+          head_ = elem->next_;
+          delete elem;
+          elem = head_;
           break;
         default:
           abort();
@@ -266,28 +257,26 @@ void TracedBuffer::ProcessTimestamp(TracedBuffer** head,
       break;
     }
   }
+  tail_ = !head_ ? head_ : tail_;
 }
 
-void TracedBuffer::Shutdown(TracedBuffer** head, void* remaining,
-                            grpc_error_handle shutdown_err) {
-  GPR_DEBUG_ASSERT(head != nullptr);
-  TracedBuffer* elem = *head;
-  while (elem != nullptr) {
-    timestamps_callback(elem->arg_, &(elem->ts_), shutdown_err);
-    auto* next = elem->next_;
+void TracedBufferList::Shutdown(void* remaining, absl::Status shutdown_err) {
+  MutexLock lock(&mu_);
+  while (head_) {
+    TracedBuffer* elem = head_;
+    g_timestamps_callback(elem->arg_, &(elem->ts_), shutdown_err);
+    head_ = head_->next_;
     delete elem;
-    elem = next;
   }
-  *head = nullptr;
   if (remaining != nullptr) {
-    timestamps_callback(remaining, nullptr, shutdown_err);
+    g_timestamps_callback(remaining, nullptr, shutdown_err);
   }
-  GRPC_ERROR_UNREF(shutdown_err);
+  tail_ = head_;
 }
 
 void grpc_tcp_set_write_timestamps_callback(
     void (*fn)(void*, Timestamps*, grpc_error_handle error)) {
-  timestamps_callback = fn;
+  g_timestamps_callback = fn;
 }
 } /* namespace grpc_core */
 
@@ -302,6 +291,6 @@ void grpc_tcp_set_write_timestamps_callback(
   (void)fn;
   gpr_log(GPR_DEBUG, "Timestamps callback is not enabled for this platform");
 }
-} /* namespace grpc_core */
+}  // namespace grpc_core
 
 #endif /* GRPC_LINUX_ERRQUEUE */

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

@@ -25,7 +25,7 @@
 
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/internal_errqueue.h"
 #include "src/core/lib/iomgr/port.h"
@@ -100,56 +100,72 @@ struct Timestamps {
 #endif           /* GRPC_LINUX_ERRQUEUE */
 };
 
-/** TracedBuffer is a class to keep track of timestamps for a specific buffer in
- * the TCP layer. We are only tracking timestamps for Linux kernels and hence
- * this class would only be used by Linux platforms. For all other platforms,
- * TracedBuffer would be an empty class.
- *
- * The timestamps collected are according to Timestamps declared
- * above.
- *
- * A TracedBuffer list is kept track of using the head element of the list. If
- * the head element of the list is nullptr, then the list is empty.
- */
+// TracedBuffer is a class to keep track of timestamps for a specific buffer in
+// the TCP layer. We are only tracking timestamps for Linux kernels and hence
+// this class would only be used by Linux platforms. For all other platforms,
+// TracedBuffer would be an empty class.
+// The timestamps collected are according to Timestamps declared above A
+// TracedBuffer list is kept track of using the head element of the list. If
+// *the head element of the list is nullptr, then the list is empty.
 #ifdef GRPC_LINUX_ERRQUEUE
-class TracedBuffer {
+
+class TracedBufferList {
  public:
-  /** Use AddNewEntry function instead of using this directly. */
-  TracedBuffer(uint32_t seq_no, void* arg)
-      : seq_no_(seq_no), arg_(arg), next_(nullptr) {}
-
-  /** Add a new entry in the TracedBuffer list pointed to by head. Also saves
-   * sendmsg_time with the current timestamp. */
-  static void AddNewEntry(TracedBuffer** head, uint32_t seq_no, 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(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
-   * with timestamps that it has. */
-  static void Shutdown(TracedBuffer** head, void* remaining,
-                       grpc_error_handle shutdown_err);
+  // Add a new entry in the TracedBuffer list pointed to by head. Also saves
+  // sendmsg_time with the current timestamp.
+  void AddNewEntry(int32_t seq_no, 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.
+  void ProcessTimestamp(struct sock_extended_err* serr,
+                        struct cmsghdr* opt_stats,
+                        struct scm_timestamping* tss);
+  // The Size() operation is slow and is used only in tests.
+  int Size() {
+    MutexLock lock(&mu_);
+    int size = 0;
+    TracedBuffer* curr = head_;
+    while (curr) {
+      ++size;
+      curr = curr->next_;
+    }
+    return size;
+  }
+  // Cleans the list by calling the callback for each traced buffer in the list
+  // with timestamps that it has.
+  void Shutdown(void* /*remaining*/, absl::Status /*shutdown_err*/);
 
  private:
-  uint32_t seq_no_;    /* The sequence number for the last byte in the buffer */
-  void* arg_;          /* The arg to pass to timestamps_callback */
-  Timestamps ts_;      /* The timestamps corresponding to this buffer */
-  TracedBuffer* next_; /* The next TracedBuffer in the list */
+  class TracedBuffer {
+   public:
+    TracedBuffer(uint32_t seq_no, void* arg) : seq_no_(seq_no), arg_(arg) {}
+
+   private:
+    friend class TracedBufferList;
+    TracedBuffer* next_ = nullptr;
+    uint32_t seq_no_; /* The sequence number for the last byte in the buffer */
+    void* arg_;       /* The arg to pass to timestamps_callback */
+    Timestamps ts_;   /* The timestamps corresponding to this buffer */
+  };
+  Mutex mu_;
+  // TracedBuffers are ordered by sequence number and would need to be processed
+  // in a FIFO order starting with the smallest sequence number. To enable this,
+  // they are stored in a singly linked with head and tail pointers which allows
+  // easy appends and forward iteration operations.
+  TracedBuffer* head_ = nullptr;
+  TracedBuffer* tail_ = nullptr;
 };
+
 #else  /* GRPC_LINUX_ERRQUEUE */
-class TracedBuffer {
+// TracedBufferList implementation is a no-op for this platform.
+class TracedBufferList {
  public:
-  /* Phony shutdown function */
-  static void Shutdown(TracedBuffer** /*head*/, void* /*remaining*/,
-                       grpc_error_handle shutdown_err) {
-    GRPC_ERROR_UNREF(shutdown_err);
-  }
+  void AddNewEntry(int32_t /*seq_no*/, int /*fd*/, void* /*arg*/) {}
+  void ProcessTimestamp(struct sock_extended_err* /*serr*/,
+                        struct cmsghdr* /*opt_stats*/,
+                        struct scm_timestamping* /*tss*/) {}
+  int Size() { return 0; }
+  void Shutdown(void* /*remaining*/, absl::Status /*shutdown_err*/) {}
 };
 #endif /* GRPC_LINUX_ERRQUEUE */
 

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

@@ -25,6 +25,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/stats.h"
+#include "src/core/lib/debug/stats_data.h"
 
 namespace grpc_core {
 
@@ -39,7 +40,7 @@ grpc_error_handle DecodeCancelStateError(gpr_atm cancel_state) {
   if (cancel_state & kErrorBit) {
     return internal::StatusGetFromHeapPtr(cancel_state & ~kErrorBit);
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 }  // namespace
@@ -81,7 +82,7 @@ void CallCombiner::TsanClosure(void* arg, grpc_error_handle error) {
   } else {
     lock.reset();
   }
-  Closure::Run(DEBUG_LOCATION, self->original_closure_, GRPC_ERROR_REF(error));
+  Closure::Run(DEBUG_LOCATION, self->original_closure_, error);
   if (lock != nullptr) {
     TSAN_ANNOTATE_RWLOCK_RELEASED(&lock->taken, true);
     bool prev = true;
@@ -117,7 +118,7 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
             "==> CallCombiner::Start() [%p] closure=%p [" DEBUG_FMT_STR
             "%s] error=%s",
             this, closure DEBUG_FMT_ARGS, reason,
-            grpc_error_std_string(error).c_str());
+            StatusToString(error).c_str());
   }
   size_t prev_size =
       static_cast<size_t>(gpr_atm_full_fetch_add(&size_, (gpr_atm)1));
@@ -175,7 +176,7 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
       closure->error_data.error = 0;
       if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
         gpr_log(GPR_INFO, "  EXECUTING FROM QUEUE: closure=%p error=%s",
-                closure, grpc_error_std_string(error).c_str());
+                closure, StatusToString(error).c_str());
       }
       ScheduleClosure(closure, error);
       break;
@@ -192,14 +193,14 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
     // If error is set, invoke the cancellation closure immediately.
     // Otherwise, store the new closure.
-    if (!GRPC_ERROR_IS_NONE(original_error)) {
+    if (!original_error.ok()) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
         gpr_log(GPR_INFO,
                 "call_combiner=%p: scheduling notify_on_cancel callback=%p "
                 "for pre-existing cancellation",
                 this, closure);
       }
-      ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_REF(original_error));
+      ExecCtx::Run(DEBUG_LOCATION, closure, original_error);
       break;
     } else {
       if (gpr_atm_full_cas(&cancel_state_, original_state,
@@ -209,7 +210,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
                   this, closure);
         }
         // If we replaced an earlier closure, invoke the original
-        // closure with GRPC_ERROR_NONE.  This allows callers to clean
+        // closure with absl::OkStatus().  This allows callers to clean
         // up any resources they may be holding for the callback.
         if (original_state != 0) {
           closure = reinterpret_cast<grpc_closure*>(original_state);
@@ -218,7 +219,7 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
                     "call_combiner=%p: scheduling old cancel callback=%p", this,
                     closure);
           }
-          ExecCtx::Run(DEBUG_LOCATION, closure, GRPC_ERROR_NONE);
+          ExecCtx::Run(DEBUG_LOCATION, closure, absl::OkStatus());
         }
         break;
       }
@@ -233,7 +234,7 @@ void CallCombiner::Cancel(grpc_error_handle error) {
   while (true) {
     gpr_atm original_state = gpr_atm_acq_load(&cancel_state_);
     grpc_error_handle original_error = DecodeCancelStateError(original_state);
-    if (!GRPC_ERROR_IS_NONE(original_error)) {
+    if (!original_error.ok()) {
       internal::StatusFreeHeapPtr(status_ptr);
       break;
     }
@@ -246,7 +247,7 @@ void CallCombiner::Cancel(grpc_error_handle error) {
                   "call_combiner=%p: scheduling notify_on_cancel callback=%p",
                   this, notify_on_cancel);
         }
-        ExecCtx::Run(DEBUG_LOCATION, notify_on_cancel, GRPC_ERROR_REF(error));
+        ExecCtx::Run(DEBUG_LOCATION, notify_on_cancel, error);
       }
       break;
     }

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

@@ -80,7 +80,7 @@ class CallCombiner {
   /// once; this allows the closure to hold references that will be freed
   /// regardless of whether or not the call was cancelled.  If a cancellation
   /// does occur, the closure will be scheduled with the cancellation error;
-  /// otherwise, it will be scheduled with GRPC_ERROR_NONE.
+  /// otherwise, it will be scheduled with absl::OkStatus().
   ///
   /// The closure will be scheduled in the following cases:
   /// - If Cancel() was called prior to registering the closure, it will be
@@ -89,7 +89,7 @@ class CallCombiner {
   ///   be scheduled with the cancellation error.
   /// - If SetNotifyOnCancel() is called again to register a new cancellation
   ///   closure, the previous cancellation closure will be scheduled with
-  ///   GRPC_ERROR_NONE.
+  ///   absl::OkStatus().
   ///
   /// If \a closure is NULL, then no closure will be invoked on
   /// cancellation; this effectively unregisters the previously set closure.
@@ -173,8 +173,7 @@ class CallCombinerClosureList {
               "CallCombinerClosureList executing closure while already "
               "holding call_combiner %p: closure=%p error=%s reason=%s",
               call_combiner, closures_[0].closure,
-              grpc_error_std_string(closures_[0].error).c_str(),
-              closures_[0].reason);
+              StatusToString(closures_[0].error).c_str(), closures_[0].reason);
     }
     // This will release the call combiner.
     ExecCtx::Run(DEBUG_LOCATION, closures_[0].closure, closures_[0].error);