grpc 1.64.3 → 1.65.0

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

@@ -25,6 +25,7 @@
 #include <limits.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
@@ -33,8 +34,6 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/address_utils/sockaddr_utils.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/iomgr/iocp_windows.h"
 #include "src/core/lib/iomgr/sockaddr.h"
@@ -45,6 +44,8 @@
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/util/string.h"
+#include "src/core/util/useful.h"
 
 #if defined(__MSYS__) && defined(GPR_ARCH_64)
 // Nasty workaround for nasty bug when using the 64 bits msys compiler
@@ -54,8 +55,6 @@
 #define GRPC_FIONBIO FIONBIO
 #endif
 
-extern grpc_core::TraceFlag grpc_tcp_trace;
-
 grpc_error_handle grpc_tcp_set_non_block(SOCKET sock) {
   int status;
   uint32_t param = 1;
@@ -124,7 +123,6 @@ typedef struct grpc_tcp {
   // to protect ourselves when requesting a shutdown.
   gpr_mu mu;
   int shutting_down;
-  grpc_error_handle shutdown_error;
 
   std::string peer_string;
   std::string local_address;
@@ -142,7 +140,7 @@ static void tcp_free(grpc_tcp* tcp) {
 #define TCP_REF(tcp, reason) tcp_ref((tcp), (reason), __FILE__, __LINE__)
 static void tcp_unref(grpc_tcp* tcp, const char* reason, const char* file,
                       int line) {
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&tcp->refcount.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "TCP unref %p : %s %" PRIdPTR " -> %" PRIdPTR, tcp, reason, val,
@@ -155,7 +153,7 @@ static void tcp_unref(grpc_tcp* tcp, const char* reason, const char* file,
 
 static void tcp_ref(grpc_tcp* tcp, const char* reason, const char* file,
                     int line) {
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_atm val = gpr_atm_no_barrier_load(&tcp->refcount.count);
     gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG,
             "TCP   ref %p : %s %" PRIdPTR " -> %" PRIdPTR, tcp, reason, val,
@@ -182,7 +180,7 @@ static void on_read(void* tcpp, grpc_error_handle error) {
   grpc_winsocket* socket = tcp->socket;
   grpc_winsocket_callback_info* info = &socket->read_info;
 
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_INFO, "TCP:%p on_read", tcp);
   }
 
@@ -203,27 +201,24 @@ static void on_read(void* tcpp, grpc_error_handle error) {
         }
         CHECK((size_t)info->bytes_transferred == tcp->read_slices->length);
 
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
-            gpr_should_log(GPR_LOG_SEVERITY_INFO)) {
+        if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
           size_t i;
           for (i = 0; i < tcp->read_slices->count; i++) {
             char* dump = grpc_dump_slice(tcp->read_slices->slices[i],
                                          GPR_DUMP_HEX | GPR_DUMP_ASCII);
-            gpr_log(GPR_INFO, "READ %p (peer=%s): %s", tcp,
-                    tcp->peer_string.c_str(), dump);
+            VLOG(2) << "READ " << tcp << " (peer=" << tcp->peer_string
+                    << "): " << dump;
             gpr_free(dump);
           }
         }
       } else {
-        if (grpc_tcp_trace.enabled()) {
+        if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
           gpr_log(GPR_INFO, "TCP:%p unref read_slice", tcp);
         }
         grpc_slice_buffer_reset_and_unref(tcp->read_slices);
         error = grpc_error_set_int(
-            tcp->shutting_down
-                ? GRPC_ERROR_CREATE_REFERENCING("TCP stream shutting down",
-                                                &tcp->shutdown_error, 1)
-                : GRPC_ERROR_CREATE("End of TCP stream"),
+            tcp->shutting_down ? GRPC_ERROR_CREATE("TCP stream shutting down")
+                               : GRPC_ERROR_CREATE("End of TCP stream"),
             grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE);
       }
     }
@@ -248,17 +243,16 @@ static void win_read(grpc_endpoint* ep, grpc_slice_buffer* read_slices,
   WSABUF buffers[MAX_WSABUF_COUNT];
   size_t i;
 
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_INFO, "TCP:%p win_read", tcp);
   }
 
   if (tcp->shutting_down) {
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION, cb,
-        grpc_error_set_int(
-            GRPC_ERROR_CREATE_REFERENCING("TCP socket is shutting down",
-                                          &tcp->shutdown_error, 1),
-            grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE));
+        grpc_error_set_int(GRPC_ERROR_CREATE("TCP socket is shutting down"),
+                           grpc_core::StatusIntProperty::kRpcStatus,
+                           GRPC_STATUS_UNAVAILABLE));
     return;
   }
 
@@ -320,7 +314,7 @@ static void on_write(void* tcpp, grpc_error_handle error) {
   grpc_winsocket_callback_info* info = &handle->write_info;
   grpc_closure* cb;
 
-  if (grpc_tcp_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp)) {
     gpr_log(GPR_INFO, "TCP:%p on_write", tcp);
   }
 
@@ -356,14 +350,13 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
   WSABUF* buffers = local_buffers;
   size_t len, async_buffers_offset = 0;
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) &&
-      gpr_should_log(GPR_LOG_SEVERITY_INFO)) {
+  if (GRPC_TRACE_FLAG_ENABLED(tcp) && ABSL_VLOG_IS_ON(2)) {
     size_t i;
     for (i = 0; i < slices->count; i++) {
       char* data =
           grpc_dump_slice(slices->slices[i], GPR_DUMP_HEX | GPR_DUMP_ASCII);
-      gpr_log(GPR_INFO, "WRITE %p (peer=%s): %s", tcp, tcp->peer_string.c_str(),
-              data);
+      VLOG(2) << "WRITE " << tcp << " (peer=" << tcp->peer_string
+              << "): " << data;
       gpr_free(data);
     }
   }
@@ -371,10 +364,9 @@ static void win_write(grpc_endpoint* ep, grpc_slice_buffer* slices,
   if (tcp->shutting_down) {
     grpc_core::ExecCtx::Run(
         DEBUG_LOCATION, cb,
-        grpc_error_set_int(
-            GRPC_ERROR_CREATE_REFERENCING("TCP socket is shutting down",
-                                          &tcp->shutdown_error, 1),
-            grpc_core::StatusIntProperty::kRpcStatus, GRPC_STATUS_UNAVAILABLE));
+        grpc_error_set_int(GRPC_ERROR_CREATE("TCP socket is shutting down"),
+                           grpc_core::StatusIntProperty::kRpcStatus,
+                           GRPC_STATUS_UNAVAILABLE));
     return;
   }
 
@@ -479,21 +471,14 @@ static void win_delete_from_pollset_set(grpc_endpoint* /* ep */,
 // we're not going to protect against these. However the IO Completion Port
 // callback will happen from another thread, so we need to protect against
 // concurrent access of the data structure in that regard.
-static void win_shutdown(grpc_endpoint* ep, grpc_error_handle why) {
+static void win_destroy(grpc_endpoint* ep) {
   grpc_tcp* tcp = (grpc_tcp*)ep;
   gpr_mu_lock(&tcp->mu);
   // At that point, what may happen is that we're already inside the IOCP
   // callback. See the comments in on_read and on_write.
-  if (!tcp->shutting_down) {
-    tcp->shutting_down = 1;
-    tcp->shutdown_error = why;
-  }
+  tcp->shutting_down = 1;
   grpc_winsocket_shutdown(tcp->socket);
   gpr_mu_unlock(&tcp->mu);
-}
-
-static void win_destroy(grpc_endpoint* ep) {
-  grpc_tcp* tcp = (grpc_tcp*)ep;
   grpc_slice_buffer_reset_and_unref(&tcp->last_read_buffer);
   TCP_UNREF(tcp, "destroy");
 }
@@ -517,7 +502,6 @@ static grpc_endpoint_vtable vtable = {win_read,
                                       win_add_to_pollset,
                                       win_add_to_pollset_set,
                                       win_delete_from_pollset_set,
-                                      win_shutdown,
                                       win_destroy,
                                       win_get_peer,
                                       win_get_local_address,

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

@@ -31,8 +31,6 @@
 #include <grpc/support/sync.h>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/spinlock.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/time.h"
@@ -41,6 +39,8 @@
 #include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/timer_heap.h"
+#include "src/core/util/spinlock.h"
+#include "src/core/util/useful.h"
 
 #define INVALID_HEAP_INDEX 0xffffffffu
 
@@ -48,9 +48,6 @@
 #define MIN_QUEUE_WINDOW_DURATION 0.01
 #define MAX_QUEUE_WINDOW_DURATION 1.0
 
-grpc_core::TraceFlag grpc_timer_trace(false, "timer");
-grpc_core::TraceFlag grpc_timer_check_trace(false, "timer_check");
-
 // A "timer shard". Contains a 'heap' and a 'list' of timers. All timers with
 // deadlines earlier than 'queue_deadline_cap' are maintained in the heap and
 // others are maintained in the list (unordered). This helps to keep the number
@@ -337,7 +334,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
   timer->hash_table_next = nullptr;
 #endif
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
     gpr_log(GPR_DEBUG, "TIMER %p: SET %" PRId64 " now %" PRId64 " call %p[%p]",
             timer, deadline.milliseconds_after_process_epoch(),
             grpc_core::Timestamp::Now().milliseconds_after_process_epoch(),
@@ -373,7 +370,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
     timer->heap_index = INVALID_HEAP_INDEX;
     list_join(&shard->list, timer);
   }
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
     gpr_log(GPR_DEBUG,
             "  .. add to shard %d with queue_deadline_cap=%" PRId64
             " => is_first_timer=%s",
@@ -396,7 +393,7 @@ static void timer_init(grpc_timer* timer, grpc_core::Timestamp deadline,
   // grpc_timer_check.
   if (is_first_timer) {
     gpr_mu_lock(&g_shared_mutables.mu);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer)) {
       gpr_log(GPR_DEBUG, "  .. old shard min_deadline=%" PRId64,
               shard->min_deadline.milliseconds_after_process_epoch());
     }
@@ -438,7 +435,7 @@ static void timer_cancel(grpc_timer* timer) {
 
   timer_shard* shard = &g_shards[grpc_core::HashPointer(timer, g_num_shards)];
   gpr_mu_lock(&shard->mu);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer)) {
     gpr_log(GPR_DEBUG, "TIMER %p: CANCEL pending=%s", timer,
             timer->pending ? "true" : "false");
   }
@@ -479,7 +476,7 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
       std::max(now, shard->queue_deadline_cap) +
       grpc_core::Duration::FromSecondsAsDouble(deadline_delta);
 
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
     gpr_log(GPR_DEBUG, "  .. shard[%d]->queue_deadline_cap --> %" PRId64,
             static_cast<int>(shard - g_shards),
             shard->queue_deadline_cap.milliseconds_after_process_epoch());
@@ -491,7 +488,7 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
             timer->deadline);
 
     if (timer_deadline < shard->queue_deadline_cap) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
         gpr_log(GPR_DEBUG, "  .. add timer with deadline %" PRId64 " to heap",
                 timer_deadline.milliseconds_after_process_epoch());
       }
@@ -508,7 +505,7 @@ static bool refill_heap(timer_shard* shard, grpc_core::Timestamp now) {
 static grpc_timer* pop_one(timer_shard* shard, grpc_core::Timestamp now) {
   grpc_timer* timer;
   for (;;) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
       gpr_log(GPR_DEBUG, "  .. shard[%d]: heap_empty=%s",
               static_cast<int>(shard - g_shards),
               grpc_timer_heap_is_empty(&shard->heap) ? "true" : "false");
@@ -521,14 +518,14 @@ static grpc_timer* pop_one(timer_shard* shard, grpc_core::Timestamp now) {
     auto timer_deadline =
         grpc_core::Timestamp::FromMillisecondsAfterProcessEpoch(
             timer->deadline);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
       gpr_log(GPR_DEBUG,
               "  .. check top timer deadline=%" PRId64 " now=%" PRId64,
               timer_deadline.milliseconds_after_process_epoch(),
               now.milliseconds_after_process_epoch());
     }
     if (timer_deadline > now) return nullptr;
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer)) {
       gpr_log(GPR_DEBUG, "TIMER %p: FIRE %" PRId64 "ms late", timer,
               (now - timer_deadline).millis());
     }
@@ -552,7 +549,7 @@ static size_t pop_timers(timer_shard* shard, grpc_core::Timestamp now,
   }
   *new_min_deadline = compute_min_deadline(shard);
   gpr_mu_unlock(&shard->mu);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
     gpr_log(GPR_DEBUG, "  .. shard[%d] popped %" PRIdPTR,
             static_cast<int>(shard - g_shards), n);
   }
@@ -591,7 +588,7 @@ static grpc_timer_check_result run_some_expired_timers(
     gpr_mu_lock(&g_shared_mutables.mu);
     result = GRPC_TIMERS_CHECKED_AND_EMPTY;
 
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
       gpr_log(
           GPR_DEBUG, "  .. shard[%d]->min_deadline = %" PRId64,
           static_cast<int>(g_shard_queue[0] - g_shards),
@@ -610,7 +607,7 @@ static grpc_timer_check_result run_some_expired_timers(
         result = GRPC_TIMERS_FIRED;
       }
 
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+      if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
         gpr_log(
             GPR_DEBUG,
             "  .. result --> %d"
@@ -670,7 +667,7 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
     if (next != nullptr) {
       *next = std::min(*next, min_timer);
     }
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
       gpr_log(GPR_DEBUG, "TIMER CHECK SKIP: now=%" PRId64 " min_timer=%" PRId64,
               now.milliseconds_after_process_epoch(),
               min_timer.milliseconds_after_process_epoch());
@@ -684,7 +681,7 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
           : GRPC_ERROR_CREATE("Shutting down timer system");
 
   // tracing
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
     std::string next_str;
     if (next == nullptr) {
       next_str = "NULL";
@@ -712,7 +709,7 @@ static grpc_timer_check_result timer_check(grpc_core::Timestamp* next) {
   grpc_timer_check_result r =
       run_some_expired_timers(now, next, shutdown_error);
   // tracing
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
     std::string next_str;
     if (next == nullptr) {
       next_str = "NULL";

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

@@ -23,8 +23,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/port.h"
+#include "src/core/util/useful.h"
 
 // Adjusts a heap so as to move a hole at position i closer to the root,
 // until a suitable position is found for element t. Then, copies t into that

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

@@ -21,6 +21,7 @@
 #include <inttypes.h>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
@@ -36,8 +37,6 @@ struct completed_thread {
   completed_thread* next;
 };
 
-extern grpc_core::TraceFlag grpc_timer_check_trace;
-
 // global mutex
 static gpr_mu g_mu;
 // are we multi-threaded
@@ -88,9 +87,7 @@ static void start_timer_thread_and_unlock(void) {
   ++g_waiter_count;
   ++g_thread_count;
   gpr_mu_unlock(&g_mu);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    gpr_log(GPR_INFO, "Spawn timer thread");
-  }
+  GRPC_TRACE_LOG(timer_check, INFO) << "Spawn timer thread";
   completed_thread* ct =
       static_cast<completed_thread*>(gpr_malloc(sizeof(*ct)));
   ct->thd = grpc_core::Thread("grpc_global_timer", timer_thread, ct);
@@ -124,17 +121,13 @@ static void run_some_timers() {
     // if there's no thread waiting with a timeout, kick an existing untimed
     // waiter so that the next deadline is not missed
     if (!g_has_timed_waiter) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-        gpr_log(GPR_INFO, "kick untimed waiter");
-      }
+      GRPC_TRACE_LOG(timer_check, INFO) << "kick untimed waiter";
       gpr_cv_signal(&g_cv_wait);
     }
     gpr_mu_unlock(&g_mu);
   }
   // without our lock, flush the exec_ctx
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    gpr_log(GPR_INFO, "flush exec_ctx");
-  }
+  GRPC_TRACE_LOG(timer_check, INFO) << "flush exec_ctx";
   grpc_core::ExecCtx::Get()->Flush();
   gpr_mu_lock(&g_mu);
   // garbage collect any threads that are dead
@@ -187,7 +180,7 @@ static bool wait_until(grpc_core::Timestamp next) {
         g_has_timed_waiter = true;
         g_timed_waiter_deadline = next;
 
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+        if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
           grpc_core::Duration wait_time = next - grpc_core::Timestamp::Now();
           gpr_log(GPR_INFO, "sleep for a %" PRId64 " milliseconds",
                   wait_time.millis());
@@ -197,14 +190,14 @@ static bool wait_until(grpc_core::Timestamp next) {
       }
     }
 
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace) &&
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check) &&
         next == grpc_core::Timestamp::InfFuture()) {
-      gpr_log(GPR_INFO, "sleep until kicked");
+      LOG(INFO) << "sleep until kicked";
     }
 
     gpr_cv_wait(&g_cv_wait, &g_mu, next.as_timespec(GPR_CLOCK_MONOTONIC));
 
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(timer_check)) {
       gpr_log(GPR_INFO, "wait ended: was_timed:%d kicked:%d",
               my_timed_waiter_generation == g_timed_waiter_generation,
               g_kicked);
@@ -250,9 +243,8 @@ static void timer_main_loop() {
 
         // Consequently, we can just sleep forever here and be happy at some
         // saved wakeup cycles.
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-          gpr_log(GPR_INFO, "timers not checked: expect another thread to");
-        }
+        GRPC_TRACE_LOG(timer_check, INFO)
+            << "timers not checked: expect another thread to";
         next = grpc_core::Timestamp::InfFuture();
         ABSL_FALLTHROUGH_INTENDED;
       case GRPC_TIMERS_CHECKED_AND_EMPTY:
@@ -276,9 +268,7 @@ static void timer_thread_cleanup(completed_thread* ct) {
   ct->next = g_completed_threads;
   g_completed_threads = ct;
   gpr_mu_unlock(&g_mu);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    gpr_log(GPR_INFO, "End timer thread");
-  }
+  GRPC_TRACE_LOG(timer_check, INFO) << "End timer thread";
 }
 
 static void timer_thread(void* completed_thread_ptr) {
@@ -317,20 +307,17 @@ void grpc_timer_manager_init(void) {
 
 static void stop_threads(void) {
   gpr_mu_lock(&g_mu);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-    gpr_log(GPR_INFO, "stop timer threads: threaded=%d", g_threaded);
-  }
+  GRPC_TRACE_LOG(timer_check, INFO)
+      << "stop timer threads: threaded=" << g_threaded;
   if (g_threaded) {
     g_threaded = false;
     gpr_cv_broadcast(&g_cv_wait);
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-      gpr_log(GPR_INFO, "num timer threads: %d", g_thread_count);
-    }
+    GRPC_TRACE_LOG(timer_check, INFO)
+        << "num timer threads: " << g_thread_count;
     while (g_thread_count > 0) {
       gpr_cv_wait(&g_cv_shutdown, &g_mu, gpr_inf_future(GPR_CLOCK_MONOTONIC));
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_timer_check_trace)) {
-        gpr_log(GPR_INFO, "num timer threads: %d", g_thread_count);
-      }
+      GRPC_TRACE_LOG(timer_check, INFO)
+          << "num timer threads: " << g_thread_count;
       gc_completed_threads();
     }
   }

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

@@ -40,11 +40,11 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/util/useful.h"
 
 void grpc_create_socketpair_if_unix(int sv[2]) {
 #ifdef GPR_WINDOWS

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

@@ -31,10 +31,10 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/util/useful.h"
 
 absl::StatusOr<std::vector<grpc_resolved_address>> grpc_resolve_vsock_address(
     absl::string_view name) {

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

@@ -26,7 +26,7 @@
 #include <string.h>
 #include <unistd.h>
 
-#include <grpc/support/log.h>
+#include "absl/log/log.h"
 
 #include "src/core/lib/gprpp/crash.h"
 #include "src/core/lib/gprpp/strerror.h"
@@ -38,8 +38,8 @@ static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   int pipefd[2];
   int r = pipe(pipefd);
   if (0 != r) {
-    gpr_log(GPR_ERROR, "pipe creation failed (%d): %s", errno,
-            grpc_core::StrError(errno).c_str());
+    LOG(ERROR) << "pipe creation failed (" << errno
+               << "): " << grpc_core::StrError(errno);
     return GRPC_OS_ERROR(errno, "pipe");
   }
   grpc_error_handle err;

data/src/core/lib/promise/activity.h

@@ -26,6 +26,7 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/log/check.h"
 #include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 
 #include <grpc/support/log.h>
@@ -121,6 +122,11 @@ class Waker {
     return wakeable_and_arg_.ActivityDebugTag();
   }
 
+  std::string DebugString() {
+    return absl::StrFormat("Waker{%p, %d}", wakeable_and_arg_.wakeable,
+                           wakeable_and_arg_.wakeup_mask);
+  }
+
   // This is for tests to assert that a waker is occupied or not.
   bool is_unwakeable() const {
     return wakeable_and_arg_.wakeable == promise_detail::unwakeable();
@@ -283,6 +289,19 @@ class ContextHolder<std::unique_ptr<Context, Deleter>> {
   std::unique_ptr<Context, Deleter> value_;
 };
 
+template <typename Context>
+class ContextHolder<RefCountedPtr<Context>> {
+ public:
+  using ContextType = Context;
+
+  explicit ContextHolder(RefCountedPtr<Context> value)
+      : value_(std::move(value)) {}
+  Context* GetContext() { return value_.get(); }
+
+ private:
+  RefCountedPtr<Context> value_;
+};
+
 template <>
 class Context<Activity> {
  public:
@@ -290,19 +309,23 @@ class Context<Activity> {
 };
 
 template <typename HeldContext>
-using ContextTypeFromHeld = typename ContextHolder<HeldContext>::ContextType;
+using ContextTypeFromHeld = typename ContextHolder<
+    typename std::remove_reference<HeldContext>::type>::ContextType;
 
 template <typename... Contexts>
-class ActivityContexts : public ContextHolder<Contexts>... {
+class ActivityContexts
+    : public ContextHolder<typename std::remove_reference<Contexts>::type>... {
  public:
   explicit ActivityContexts(Contexts&&... contexts)
-      : ContextHolder<Contexts>(std::forward<Contexts>(contexts))... {}
+      : ContextHolder<typename std::remove_reference<Contexts>::type>(
+            std::forward<Contexts>(contexts))... {}
 
   class ScopedContext : public Context<ContextTypeFromHeld<Contexts>>... {
    public:
     explicit ScopedContext(ActivityContexts* contexts)
         : Context<ContextTypeFromHeld<Contexts>>(
-              static_cast<ContextHolder<Contexts>*>(contexts)
+              static_cast<ContextHolder<
+                  typename std::remove_reference<Contexts>::type>*>(contexts)
                   ->GetContext())... {
       // Silence `unused-but-set-parameter` in case of Contexts = {}
       (void)contexts;

data/src/core/lib/promise/cancel_callback.h

@@ -17,7 +17,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/resource_quota/arena.h"
 
 namespace grpc_core {
 
@@ -31,6 +33,7 @@ class Handler {
   Handler& operator=(const Handler&) = delete;
   ~Handler() {
     if (!done_) {
+      promise_detail::Context<Arena> ctx(arena_.get());
       fn_();
     }
   }
@@ -48,6 +51,13 @@ class Handler {
 
  private:
   Fn fn_;
+  // Since cancellation happens at destruction time we need to either capture
+  // context here (via the arena), or make sure that no promise is destructed
+  // without an Arena context on the stack. The latter is an eternal game of
+  // whackamole, so we're choosing the former for now.
+  // TODO(ctiller): re-evaluate at some point in the future.
+  RefCountedPtr<Arena> arena_ =
+      HasContext<Arena>() ? GetContext<Arena>()->Ref() : nullptr;
   bool done_ = false;
 };
 
@@ -70,6 +80,20 @@ auto OnCancel(MainFn main_fn, CancelFn cancel_fn) {
   };
 }
 
+// Similar to OnCancel, but returns a factory that uses main_fn to construct the
+// resulting promise. If the factory is dropped without being called, cancel_fn
+// is called.
+template <typename MainFn, typename CancelFn>
+auto OnCancelFactory(MainFn main_fn, CancelFn cancel_fn) {
+  return [on_cancel =
+              cancel_callback_detail::Handler<CancelFn>(std::move(cancel_fn)),
+          main_fn = std::move(main_fn)]() mutable {
+    auto r = main_fn();
+    on_cancel.Done();
+    return r;
+  };
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_PROMISE_CANCEL_CALLBACK_H

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

@@ -119,6 +119,17 @@ T* GetContext() {
   return p;
 }
 
+// Retrieve the current value of a context, or nullptr if the value is unset.
+template <typename T>
+T* MaybeGetContext() {
+  return promise_detail::Context<T>::get();
+}
+
+template <typename T>
+void SetContext(T* p) {
+  promise_detail::Context<T>::set(p);
+}
+
 // Given a promise and a context, return a promise that has that context set.
 template <typename T, typename F>
 promise_detail::WithContext<T, F> WithContext(F f, T* context) {