grpc 1.75.0 → 1.78.1

data/src/core/util/memory_usage.h

@@ -23,12 +23,14 @@
 #include <utility>
 #include <vector>
 
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/time.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
-#include "src/core/util/time.h"
 
 namespace grpc_core {
 
@@ -88,6 +90,10 @@ template <typename T>
 constexpr Category kMemoryUsageCategory<std::shared_ptr<T>> =
     Category::kOwnedPointer;
 
+template <typename T>
+constexpr Category kMemoryUsageCategory<absl::StatusOr<T>> =
+    Category::kAbslStatusOr;
+
 template <typename T>
 constexpr Category kMemoryUsageCategory<std::vector<T>> = Category::kVector;
 
@@ -135,6 +141,10 @@ size_t MemoryUsageOf(const T& x) {
     return sizeof(T);
   } else if constexpr (std::is_same_v<T, Duration>) {
     return sizeof(T);
+  } else if constexpr (std::is_same_v<T, Slice>) {
+    return sizeof(T) + x.size();  // may overestimate a bit
+  } else if constexpr (std::is_same_v<T, SliceBuffer>) {
+    return sizeof(T) + x.Length();  // may overestimate a bit
   } else if constexpr (category == Category::kSimple) {
     return sizeof(T);
   } else if constexpr (category == Category::kOwnedPointer) {
@@ -263,6 +273,12 @@ size_t MemoryUsageOf(const std::tuple<Args...>& t) {
       [](const auto&... args) { return (MemoryUsageOf(args) + ... + 0); }, t);
 }
 
+// This does not calculate the overhead of the variant itself.
+template <typename... T>
+size_t MemoryUsageOf(const std::variant<T...>& t) {
+  return std::visit([](const auto& x) { return MemoryUsageOf(x); }, t);
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_UTIL_MEMORY_USAGE_H

data/src/core/util/mpscq.h

@@ -23,8 +23,8 @@
 
 #include <atomic>
 
-#include "absl/log/check.h"
 #include "src/core/util/sync.h"
+#include "absl/log/check.h"
 
 namespace grpc_core {
 

data/src/core/util/notification.h

@@ -17,9 +17,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/util/sync.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
-#include "src/core/util/sync.h"
 
 namespace grpc_core {
 

data/src/core/util/posix/cpu.cc

@@ -27,9 +27,9 @@
 #include <string.h>
 #include <unistd.h>
 
-#include "absl/log/log.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/useful.h"
+#include "absl/log/log.h"
 
 static long ncpus = 0;
 

data/src/core/util/posix/directory_reader.cc

@@ -25,7 +25,7 @@
 #include "absl/strings/string_view.h"
 
 #if defined(GPR_LINUX) || defined(GPR_ANDROID) || defined(GPR_FREEBSD) || \
-    defined(GPR_APPLE) || defined(GPR_NETBSD)
+    defined(GPR_APPLE) || defined(GPR_NETBSD) || defined(GPR_OPENBSD)
 
 #include <dirent.h>
 
@@ -79,4 +79,5 @@ absl::Status DirectoryReaderImpl::ForEach(
 }
 }  // namespace grpc_core
 
-#endif  // GPR_LINUX || GPR_ANDROID || GPR_FREEBSD || GPR_APPLE
+#endif  // GPR_LINUX || GPR_ANDROID || GPR_FREEBSD || GPR_APPLE ||
+        // GPR_NETBSD || GPR_OPENBSD

data/src/core/util/posix/stat.cc

@@ -27,10 +27,10 @@
 #include <errno.h>
 #include <sys/stat.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/util/stat.h"
 #include "src/core/util/strerror.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 

data/src/core/util/posix/sync.cc

@@ -27,40 +27,40 @@
 #include <grpc/support/time.h>
 #include <time.h>
 
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 void gpr_mu_init(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_mutex_init(&mu->mutex, nullptr), 0);
+  GRPC_CHECK_EQ(pthread_mutex_init(&mu->mutex, nullptr), 0);
   mu->leak_checker = static_cast<int*>(malloc(sizeof(*mu->leak_checker)));
-  CHECK_NE(mu->leak_checker, nullptr);
+  GRPC_CHECK_NE(mu->leak_checker, nullptr);
 #else
-  CHECK_EQ(pthread_mutex_init(mu, nullptr), 0);
+  GRPC_CHECK_EQ(pthread_mutex_init(mu, nullptr), 0);
 #endif
 }
 
 void gpr_mu_destroy(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_mutex_destroy(&mu->mutex), 0);
+  GRPC_CHECK_EQ(pthread_mutex_destroy(&mu->mutex), 0);
   free(mu->leak_checker);
 #else
-  CHECK_EQ(pthread_mutex_destroy(mu), 0);
+  GRPC_CHECK_EQ(pthread_mutex_destroy(mu), 0);
 #endif
 }
 
 void gpr_mu_lock(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_mutex_lock(&mu->mutex), 0);
+  GRPC_CHECK_EQ(pthread_mutex_lock(&mu->mutex), 0);
 #else
-  CHECK_EQ(pthread_mutex_lock(mu), 0);
+  GRPC_CHECK_EQ(pthread_mutex_lock(mu), 0);
 #endif
 }
 
 void gpr_mu_unlock(gpr_mu* mu) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_mutex_unlock(&mu->mutex), 0);
+  GRPC_CHECK_EQ(pthread_mutex_unlock(&mu->mutex), 0);
 #else
-  CHECK_EQ(pthread_mutex_unlock(mu), 0);
+  GRPC_CHECK_EQ(pthread_mutex_unlock(mu), 0);
 #endif
 }
 
@@ -71,7 +71,7 @@ int gpr_mu_trylock(gpr_mu* mu) {
 #else
   err = pthread_mutex_trylock(mu);
 #endif
-  CHECK(err == 0 || err == EBUSY);
+  GRPC_CHECK(err == 0 || err == EBUSY);
   return err == 0;
 }
 
@@ -79,26 +79,26 @@ int gpr_mu_trylock(gpr_mu* mu) {
 
 void gpr_cv_init(gpr_cv* cv) {
   pthread_condattr_t attr;
-  CHECK_EQ(pthread_condattr_init(&attr), 0);
+  GRPC_CHECK_EQ(pthread_condattr_init(&attr), 0);
 #if GPR_LINUX
-  CHECK_EQ(pthread_condattr_setclock(&attr, CLOCK_MONOTONIC), 0);
+  GRPC_CHECK_EQ(pthread_condattr_setclock(&attr, CLOCK_MONOTONIC), 0);
 #endif  // GPR_LINUX
 
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_cond_init(&cv->cond_var, &attr), 0);
+  GRPC_CHECK_EQ(pthread_cond_init(&cv->cond_var, &attr), 0);
   cv->leak_checker = static_cast<int*>(malloc(sizeof(*cv->leak_checker)));
-  CHECK_NE(cv->leak_checker, nullptr);
+  GRPC_CHECK_NE(cv->leak_checker, nullptr);
 #else
-  CHECK_EQ(pthread_cond_init(cv, &attr), 0);
+  GRPC_CHECK_EQ(pthread_cond_init(cv, &attr), 0);
 #endif
 }
 
 void gpr_cv_destroy(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_cond_destroy(&cv->cond_var), 0);
+  GRPC_CHECK_EQ(pthread_cond_destroy(&cv->cond_var), 0);
   free(cv->leak_checker);
 #else
-  CHECK_EQ(pthread_cond_destroy(cv), 0);
+  GRPC_CHECK_EQ(pthread_cond_destroy(cv), 0);
 #endif
 }
 
@@ -127,30 +127,30 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
     err = pthread_cond_timedwait(cv, mu, &abs_deadline_ts);
 #endif
   }
-  CHECK(err == 0 || err == ETIMEDOUT || err == EAGAIN);
+  GRPC_CHECK(err == 0 || err == ETIMEDOUT || err == EAGAIN);
   return err == ETIMEDOUT;
 }
 
 void gpr_cv_signal(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_cond_signal(&cv->cond_var), 0);
+  GRPC_CHECK_EQ(pthread_cond_signal(&cv->cond_var), 0);
 #else
-  CHECK_EQ(pthread_cond_signal(cv), 0);
+  GRPC_CHECK_EQ(pthread_cond_signal(cv), 0);
 #endif
 }
 
 void gpr_cv_broadcast(gpr_cv* cv) {
 #ifdef GRPC_ASAN_ENABLED
-  CHECK_EQ(pthread_cond_broadcast(&cv->cond_var), 0);
+  GRPC_CHECK_EQ(pthread_cond_broadcast(&cv->cond_var), 0);
 #else
-  CHECK_EQ(pthread_cond_broadcast(cv), 0);
+  GRPC_CHECK_EQ(pthread_cond_broadcast(cv), 0);
 #endif
 }
 
 //----------------------------------------
 
 void gpr_once_init(gpr_once* once, void (*init_function)(void)) {
-  CHECK_EQ(pthread_once(once, init_function), 0);
+  GRPC_CHECK_EQ(pthread_once(once, init_function), 0);
 }
 
 #endif  // defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) &&

data/src/core/util/posix/thd.cc

@@ -34,13 +34,13 @@
 #include <string.h>
 #include <unistd.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/fork.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/thd.h"
 #include "src/core/util/useful.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 namespace {

data/src/core/util/posix/tmpfile.cc

@@ -27,12 +27,12 @@
 #include <string.h>
 #include <unistd.h>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/strerror.h"
 #include "src/core/util/string.h"
 #include "src/core/util/tmpfile.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
   FILE* result = nullptr;

data/src/core/util/postmortem_emit.cc

@@ -0,0 +1,52 @@
+// Copyright 2025 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 "src/core/util/postmortem_emit.h"
+
+#include <iostream>
+#include <sstream>
+
+#include "src/core/channelz/channelz_registry.h"
+#include "src/core/telemetry/stats.h"
+
+namespace grpc_core {
+
+namespace {
+
+void RunPostMortem(std::ostream& out) {
+  out << "===========================================================\n";
+  out << "🛑 gRPC Test Postmortem Analysis 🛑\n";
+  out << "===========================================================\n";
+
+  out << "❗ gRPC Statistics:\n"
+      << StatsAsJson(global_stats().Collect().get()) << "\n";
+
+  out << "❗ channelz entities:\n";
+  for (const auto& node : channelz::ChannelzRegistry::GetAllEntities()) {
+    out << "  🔴 [" << node->uuid() << ":"
+        << channelz::BaseNode::EntityTypeString(node->type())
+        << "]: " << node->RenderJsonString() << "\n";
+  }
+}
+
+}  // namespace
+
+void PostMortemEmit() { RunPostMortem(std::cerr); }
+
+void SilentPostMortemEmit() {
+  std::ostringstream out;
+  RunPostMortem(out);
+}
+
+}  // namespace grpc_core

data/src/core/util/postmortem_emit.h

@@ -0,0 +1,30 @@
+// Copyright 2025 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_UTIL_POSTMORTEM_EMIT_H
+#define GRPC_SRC_CORE_UTIL_POSTMORTEM_EMIT_H
+
+namespace grpc_core {
+
+// Emit useful post mortem analysis from whatever in-process data we have.
+void PostMortemEmit();
+
+// Does all the work of PostMortemEmit, but doesn't emit anything.
+// This is useful for verifying that PostMortemEmit *would* succeed...
+// which means especially that channelz is working.
+void SilentPostMortemEmit();
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_UTIL_POSTMORTEM_EMIT_H

data/src/core/util/ref_counted.h

@@ -25,12 +25,12 @@
 #include <cassert>
 #include <cinttypes>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
 #include "src/core/util/atomic_utils.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/down_cast.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 

data/src/core/util/ref_counted_ptr.h

@@ -26,9 +26,9 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/hash/hash.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/down_cast.h"
+#include "absl/hash/hash.h"
 
 namespace grpc_core {
 
@@ -464,6 +464,11 @@ struct WeakRefCountedPtrEq {
   }
 };
 
+template <typename To, typename From>
+RefCountedPtr<To> DownCastRefCountedPtr(RefCountedPtr<From> ptr) {
+  return RefCountedPtr<To>(DownCast<To*>(ptr.release()));
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_UTIL_REF_COUNTED_PTR_H

data/src/core/util/ref_counted_string.h

@@ -22,9 +22,9 @@
 
 #include <string>
 
-#include "absl/strings/string_view.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/util/single_set_ptr.h

@@ -20,8 +20,8 @@
 #include <atomic>
 #include <memory>
 
-#include "absl/log/check.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "absl/log/check.h"
 
 namespace grpc_core {
 
@@ -60,6 +60,8 @@ class SingleSetPtr {
   T* Set(std::unique_ptr<T, Deleter> ptr) { return Set(ptr.release()); }
 
   // Clear the pointer.
+  // Caller must ensure that no other thread is concurrently trying to set the
+  // pointer, or read the pointer.
   void Reset() { Delete(p_.exchange(nullptr, std::memory_order_acq_rel)); }
 
   bool is_set() const { return p_.load(std::memory_order_relaxed) != nullptr; }

data/src/core/util/status_helper.cc

@@ -23,14 +23,6 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/strings/cord.h"
-#include "absl/strings/escaping.h"
-#include "absl/strings/match.h"
-#include "absl/strings/numbers.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/time/clock.h"
 #include "google/protobuf/any.upb.h"
 #include "google/rpc/status.upb.h"
 #include "src/core/lib/experiments/experiments.h"
@@ -40,6 +32,14 @@
 #include "src/core/util/time.h"
 #include "upb/base/string_view.h"
 #include "upb/mem/arena.hpp"
+#include "absl/log/check.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/time/clock.h"
 
 namespace grpc_core {
 

data/src/core/util/status_helper.h

@@ -26,10 +26,10 @@
 #include <string>
 #include <vector>
 
+#include "src/core/util/debug_location.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
-#include "src/core/util/debug_location.h"
 
 extern "C" {
 struct google_rpc_Status;

data/src/core/util/string.cc

@@ -29,10 +29,10 @@
 #include <string.h>
 #include <time.h>
 
-#include "absl/strings/str_cat.h"
-#include "absl/time/time.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/useful.h"
+#include "absl/strings/str_cat.h"
+#include "absl/time/time.h"
 
 char* gpr_strdup(const char* src) {
   char* dst;

data/src/core/util/sync_abseil.cc

@@ -26,11 +26,11 @@
 #include <grpc/support/time.h>
 #include <time.h>
 
+#include "src/core/util/time_util.h"
 #include "absl/base/call_once.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
-#include "src/core/util/time_util.h"
 
 void gpr_mu_init(gpr_mu* mu) {
   static_assert(sizeof(gpr_mu) == sizeof(absl::Mutex),

data/src/core/util/table.h

@@ -23,9 +23,9 @@
 #include <type_traits>
 #include <utility>
 
+#include "src/core/util/bitset.h"
 #include "absl/meta/type_traits.h"
 #include "absl/utility/utility.h"
-#include "src/core/util/bitset.h"
 
 namespace grpc_core {
 

data/src/core/util/time.cc

@@ -23,10 +23,10 @@
 #include <string>
 #include <utility>
 
+#include "src/core/util/no_destruct.h"
 #include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_format.h"
-#include "src/core/util/no_destruct.h"
 
 // IWYU pragma: no_include <ratio>
 

data/src/core/util/time_precise.cc

@@ -27,8 +27,8 @@
 
 #include <algorithm>
 
-#include "absl/log/log.h"
 #include "src/core/util/time_precise.h"
+#include "absl/log/log.h"
 
 #ifndef GPR_CYCLE_COUNTER_CUSTOM
 #if GPR_CYCLE_COUNTER_RDTSC_32 || GPR_CYCLE_COUNTER_RDTSC_64