grpc 1.84.1 → 1.85.0.pre1

data/third_party/abseil-cpp/absl/base/internal/hardening.h

@@ -0,0 +1,136 @@
+//
+// Copyright 2026 The Abseil 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
+//
+//      https://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.
+//
+// -----------------------------------------------------------------------------
+// File: hardening.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines macros and functions for performing Abseil
+// hardening checks and aborts.
+
+#ifndef ABSL_BASE_INTERNAL_HARDENING_H_
+#define ABSL_BASE_INTERNAL_HARDENING_H_
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/base/options.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace base_internal {
+
+// `HardeningAssert` performs runtime checks when Abseil Hardening is enabled,
+// even if `NDEBUG` is defined.
+//
+// When `NDEBUG` is not defined, `HardeningAssert`'s behavior is identical to
+// `ABSL_ASSERT`.
+//
+// Prefer a more specific assertion function over this more general one,
+// as assertion functions which perform the comparison themselves
+// can have the cost of the comparison attributed to them.
+constexpr void HardeningAssert(bool cond) {
+  ABSL_ASSERT(cond);
+#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
+  if (ABSL_PREDICT_FALSE(!cond)) {
+    base_internal::HardeningAbort();
+  }
+#endif
+}
+
+// `HardeningAssertSlow` is used to perform runtime checks which are too
+// computationally expensive to enable widely by default.
+//
+// When `NDEBUG` is not defined, `HardeningAssertSlow`'s behavior is identical
+// to `ABSL_ASSERT`.
+constexpr void HardeningAssertSlow(bool cond) {
+  ABSL_ASSERT(cond);
+#if (ABSL_OPTION_HARDENED == 1) && defined(NDEBUG)
+  if (ABSL_PREDICT_FALSE(!cond)) {
+    base_internal::HardeningAbort();
+  }
+#endif
+}
+
+template <typename T>
+constexpr void HardeningAssertGT(T val1, T val2) {
+  ABSL_ASSERT(val1 > val2);
+#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
+  if (!ABSL_PREDICT_TRUE(val1 > val2)) {
+    base_internal::HardeningAbort();
+  }
+#endif
+}
+
+template <typename T>
+constexpr void HardeningAssertGE(T val1, T val2) {
+  ABSL_ASSERT(val1 >= val2);
+#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
+  if (!ABSL_PREDICT_TRUE(val1 >= val2)) {
+    base_internal::HardeningAbort();
+  }
+#endif
+}
+
+template <typename T>
+constexpr void HardeningAssertLT(T val1, T val2) {
+  ABSL_ASSERT(val1 < val2);
+#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
+  if (!ABSL_PREDICT_TRUE(val1 < val2)) {
+    base_internal::HardeningAbort();
+  }
+#endif
+}
+
+template <typename T>
+constexpr void HardeningAssertLE(T val1, T val2) {
+  ABSL_ASSERT(val1 <= val2);
+#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
+  if (!ABSL_PREDICT_TRUE(val1 <= val2)) {
+    base_internal::HardeningAbort();
+  }
+#endif
+}
+
+constexpr void HardeningAssertInBounds(size_t index, size_t size) {
+  HardeningAssertLT(index, size);
+}
+
+template <typename T>
+constexpr void HardeningAssertNonEmpty(const T& container) {
+  ABSL_ASSERT(!container.empty());
+#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
+  if (ABSL_PREDICT_FALSE(container.empty())) {
+    base_internal::HardeningAbort();
+  }
+#endif
+}
+
+template <typename T>
+constexpr void HardeningAssertNonNull(T ptr) {
+  ABSL_ASSERT(ptr != nullptr);
+#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
+  if (ABSL_PREDICT_FALSE(ptr == nullptr)) {
+    base_internal::HardeningAbort();
+  }
+#endif
+}
+
+}  // namespace base_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_BASE_INTERNAL_HARDENING_H_

data/third_party/abseil-cpp/absl/base/internal/iterator_traits.h

@@ -37,7 +37,7 @@ struct IteratorCategory {};
 template <typename Iterator>
 struct IteratorCategory<
     Iterator,
-    absl::void_t<typename std::iterator_traits<Iterator>::iterator_category>> {
+    std::void_t<typename std::iterator_traits<Iterator>::iterator_category>> {
   using type = typename std::iterator_traits<Iterator>::iterator_category;
 };
 
@@ -47,7 +47,7 @@ struct IteratorConceptImpl : IteratorCategory<Iterator> {};
 template <typename Iterator>
 struct IteratorConceptImpl<
     Iterator,
-    absl::void_t<typename std::iterator_traits<Iterator>::iterator_concept>> {
+    std::void_t<typename std::iterator_traits<Iterator>::iterator_concept>> {
   using type = typename std::iterator_traits<Iterator>::iterator_concept;
 };
 
@@ -60,6 +60,10 @@ template <typename IteratorTag, typename Iterator>
 using IsAtLeastIterator =
     std::is_convertible<IteratorConcept<Iterator>, IteratorTag>;
 
+template <typename Iterator>
+using IsAtLeastInputIterator =
+    IsAtLeastIterator<std::input_iterator_tag, Iterator>;
+
 template <typename Iterator>
 using IsAtLeastForwardIterator =
     IsAtLeastIterator<std::forward_iterator_tag, Iterator>;

data/third_party/abseil-cpp/absl/base/internal/low_level_alloc.cc

@@ -19,6 +19,9 @@
 
 #include "absl/base/internal/low_level_alloc.h"
 
+#include <stdint.h>
+
+#include <optional>
 #include <type_traits>
 
 #include "absl/base/call_once.h"
@@ -44,6 +47,12 @@
 
 #ifdef __linux__
 #include <sys/prctl.h>
+#ifndef PR_SET_VMA
+#define PR_SET_VMA 0x53564d41
+#endif
+#ifndef PR_SET_VMA_ANON_NAME
+#define PR_SET_VMA_ANON_NAME 0
+#endif
 #endif
 
 #include <string.h>
@@ -219,6 +228,32 @@ struct LowLevelAlloc::Arena {
   uint32_t random ABSL_GUARDED_BY(mu);
 };
 
+// ---------------------------------------------------------------
+// An async-signal-safe arena for LowLevelAlloc
+static std::atomic<base_internal::LowLevelAlloc::Arena *> g_sig_safe_arena;
+
+base_internal::LowLevelAlloc::Arena *SigSafeArena() {
+  return g_sig_safe_arena.load(std::memory_order_acquire);
+}
+
+void InitSigSafeArena() {
+  if (SigSafeArena() == nullptr) {
+    uint32_t flags = 0;
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+    flags |= base_internal::LowLevelAlloc::kAsyncSignalSafe;
+#endif
+    base_internal::LowLevelAlloc::Arena *new_arena =
+        base_internal::LowLevelAlloc::NewArena(flags);
+    base_internal::LowLevelAlloc::Arena *old_value = nullptr;
+    if (!g_sig_safe_arena.compare_exchange_strong(old_value, new_arena,
+                                                  std::memory_order_release,
+                                                  std::memory_order_relaxed)) {
+      // We lost a race to allocate an arena; deallocate.
+      base_internal::LowLevelAlloc::DeleteArena(new_arena);
+    }
+  }
+}
+
 namespace {
 // Static storage space for the lazily-constructed, default global arena
 // instances.  We require this space because the whole point of LowLevelAlloc
@@ -289,11 +324,11 @@ class ABSL_SCOPED_LOCKABLE ArenaLock {
       mask_valid_ = pthread_sigmask(SIG_BLOCK, &all, &mask_) == 0;
     }
 #endif
-    arena_->mu.Lock();
+    arena_->mu.lock();
   }
   ~ArenaLock() { ABSL_RAW_CHECK(left_, "haven't left Arena region"); }
   void Leave() ABSL_UNLOCK_FUNCTION() {
-    arena_->mu.Unlock();
+    arena_->mu.unlock();
 #ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
     if (mask_valid_) {
       const int err = pthread_sigmask(SIG_SETMASK, &mask_, nullptr);
@@ -544,7 +579,7 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
       }
       // we unlock before mmap() both because mmap() may call a callback hook,
       // and because it may be slow.
-      arena->mu.Unlock();
+      arena->mu.unlock();
       // mmap generous 64K chunks to decrease
       // the chances/impact of fragmentation:
       size_t new_pages_size = RoundUp(req_rnd, arena->pagesize * 16);
@@ -583,7 +618,7 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
 #endif
 #endif  // __linux__
 #endif  // _WIN32
-      arena->mu.Lock();
+      arena->mu.lock();
       s = reinterpret_cast<AllocList *>(new_pages);
       s->header.size = new_pages_size;
       // Pretend the block is allocated; call AddToFreelist() to free it.

data/third_party/abseil-cpp/absl/base/internal/low_level_alloc.h

@@ -120,6 +120,12 @@ class LowLevelAlloc {
   LowLevelAlloc();      // no instances
 };
 
+// Returns a global async-signal-safe arena for LowLevelAlloc.
+LowLevelAlloc::Arena *SigSafeArena();
+
+// Ensures the global async-signal-safe arena for LowLevelAlloc is initialized.
+void InitSigSafeArena();
+
 }  // namespace base_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

data/third_party/abseil-cpp/absl/base/internal/low_level_scheduling.h

@@ -18,8 +18,11 @@
 #ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
 #define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
 
+#include <atomic>
+
 #include "absl/base/internal/raw_logging.h"
 #include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/internal/thread_identity.h"
 #include "absl/base/macros.h"
 
 // The following two declarations exist so SchedulingGuard may friend them with
@@ -64,7 +67,6 @@ class SchedulingGuard {
   SchedulingGuard(const SchedulingGuard&) = delete;
   SchedulingGuard& operator=(const SchedulingGuard&) = delete;
 
- private:
   // Disable cooperative rescheduling of the calling thread.  It may still
   // initiate scheduling operations (e.g. wake-ups), however, it may not itself
   // reschedule.  Nestable.  The returned result is opaque, clients should not
@@ -96,13 +98,6 @@ class SchedulingGuard {
    private:
     int scheduling_disabled_depth_;
   };
-
-  // Access to SchedulingGuard is explicitly permitted.
-  friend class absl::CondVar;
-  friend class absl::Mutex;
-  friend class SchedulingHelper;
-  friend class SpinLock;
-  friend int absl::synchronization_internal::MutexDelay(int32_t c, int mode);
 };
 
 //------------------------------------------------------------------------------
@@ -110,21 +105,88 @@ class SchedulingGuard {
 //------------------------------------------------------------------------------
 
 inline bool SchedulingGuard::ReschedulingIsAllowed() {
-  return false;
+  ThreadIdentity* identity = CurrentThreadIdentityIfPresent();
+  if (identity != nullptr) {
+    ThreadIdentity::SchedulerState* state = &identity->scheduler_state;
+    // For a thread to be eligible for re-scheduling it must have a bound
+    // schedulable (otherwise it's not cooperative) and not be within a
+    // SchedulerGuard region.
+    return state->bound_schedulable.load(std::memory_order_relaxed) !=
+               nullptr &&
+           state->scheduling_disabled_depth.load(std::memory_order_relaxed) ==
+               0;
+  } else {
+    // Cooperative threads always have a ThreadIdentity.
+    return false;
+  }
 }
 
+// We don't use [[nodiscard]] here as some clients (e.g.
+// FinishPotentiallyBlockingRegion()) cannot yet properly consume it.
 inline bool SchedulingGuard::DisableRescheduling() {
-  return false;
+  ThreadIdentity* identity;
+  identity = CurrentThreadIdentityIfPresent();
+  if (identity != nullptr) {
+    // The depth is accessed concurrently from other threads, so it must be
+    // atomic, but it's only mutated from this thread, so we don't need an
+    // atomic increment.
+    int old_val = identity->scheduler_state.scheduling_disabled_depth.load(
+        std::memory_order_relaxed);
+    identity->scheduler_state.scheduling_disabled_depth.store(
+        old_val + 1, std::memory_order_relaxed);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+inline void SchedulingGuard::EnableRescheduling(bool disable_result) {
+  if (!disable_result) {
+    // There was no installed thread identity at the time that scheduling was
+    // disabled, so we have nothing to do.  This is an implementation detail
+    // that may change in the future, clients may not depend on it.
+    // EnableRescheduling() must always be called.
+    return;
+  }
+
+  ThreadIdentity* identity;
+  // A thread identity exists, see above
+  identity = CurrentThreadIdentityIfPresent();
+  // The depth is accessed concurrently from other threads, so it must be
+  // atomic, but it's only mutated from this thread, so we don't need an atomic
+  // decrement.
+  int old_val = identity->scheduler_state.scheduling_disabled_depth.load(
+      std::memory_order_relaxed);
+  identity->scheduler_state.scheduling_disabled_depth.store(
+      old_val - 1, std::memory_order_relaxed);
 }
 
-inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
-  return;
+inline SchedulingGuard::ScopedEnable::ScopedEnable() {
+  ThreadIdentity* identity;
+  identity = CurrentThreadIdentityIfPresent();
+  if (identity != nullptr) {
+    scheduling_disabled_depth_ =
+        identity->scheduler_state.scheduling_disabled_depth.load(
+            std::memory_order_relaxed);
+    if (scheduling_disabled_depth_ != 0) {
+      // The store below does not need to be compare_exchange because
+      // the value is never modified concurrently (only accessed).
+      identity->scheduler_state.scheduling_disabled_depth.store(
+          0, std::memory_order_relaxed);
+    }
+  } else {
+    scheduling_disabled_depth_ = 0;
+  }
 }
 
-inline SchedulingGuard::ScopedEnable::ScopedEnable()
-    : scheduling_disabled_depth_(0) {}
 inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
-  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
+  if (scheduling_disabled_depth_ == 0) {
+    return;
+  }
+  ThreadIdentity* identity = CurrentThreadIdentityIfPresent();
+  // itentity is guaranteed to exist, see the constructor above.
+  identity->scheduler_state.scheduling_disabled_depth.store(
+      scheduling_disabled_depth_, std::memory_order_relaxed);
 }
 
 }  // namespace base_internal

data/third_party/abseil-cpp/absl/base/internal/raw_logging.cc

@@ -41,9 +41,8 @@
 //
 // This preprocessor token is also defined in raw_io.cc.  If you need to copy
 // this, consider moving both to config.h instead.
-#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
-    defined(__hexagon__) || defined(__Fuchsia__) ||                     \
-    defined(__native_client__) || defined(__OpenBSD__) ||               \
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) ||     \
+    defined(__hexagon__) || defined(__Fuchsia__) || defined(__OpenBSD__) || \
     defined(__EMSCRIPTEN__) || defined(__ASYLO__)
 
 #include <unistd.h>
@@ -158,7 +157,7 @@ void RawLogVA(absl::LogSeverity severity, const char* file, int line,
 #endif
 
 #ifdef ABSL_MIN_LOG_LEVEL
-  if (severity < static_cast<absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) &&
+  if (severity < static_cast<absl::LogSeverityAtLeast>(ABSL_MIN_LOG_LEVEL) &&
       severity < absl::LogSeverity::kFatal) {
     enabled = false;
   }

data/third_party/abseil-cpp/absl/base/internal/spinlock.cc

@@ -16,15 +16,18 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cstdint>
 #include <limits>
 
 #include "absl/base/attributes.h"
+#include "absl/base/call_once.h"
 #include "absl/base/config.h"
 #include "absl/base/internal/atomic_hook.h"
 #include "absl/base/internal/cycleclock.h"
+#include "absl/base/internal/scheduling_mode.h"
 #include "absl/base/internal/spinlock_wait.h"
 #include "absl/base/internal/sysinfo.h" /* For NumCPUs() */
-#include "absl/base/call_once.h"
+#include "absl/base/internal/tsan_mutex_interface.h"
 
 // Description of lock-word:
 //  31..00: [............................3][2][1][0]
@@ -58,7 +61,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace base_internal {
 
-ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static base_internal::AtomicHook<void (*)(
+ABSL_INTERNAL_ATOMIC_HOOK_ATTRIBUTES static AtomicHook<void (*)(
     const void *lock, int64_t wait_cycles)>
     submit_profile_data;
 
@@ -67,25 +70,24 @@ void RegisterSpinLockProfiler(void (*fn)(const void *contendedlock,
   submit_profile_data.Store(fn);
 }
 
-// Uncommon constructors.
-SpinLock::SpinLock(base_internal::SchedulingMode mode)
-    : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {
-  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
-}
-
 // Monitor the lock to see if its value changes within some time period
-// (adaptive_spin_count loop iterations). The last value read from the lock
+// (adaptive_spin_count_ loop iterations). The last value read from the lock
 // is returned from the method.
+ABSL_CONST_INIT std::atomic<int> SpinLock::adaptive_spin_count_{0};
 uint32_t SpinLock::SpinLoop() {
   // We are already in the slow path of SpinLock, initialize the
   // adaptive_spin_count here.
-  ABSL_CONST_INIT static absl::once_flag init_adaptive_spin_count;
-  ABSL_CONST_INIT static int adaptive_spin_count = 0;
-  base_internal::LowLevelCallOnce(&init_adaptive_spin_count, []() {
-    adaptive_spin_count = base_internal::NumCPUs() > 1 ? 1000 : 1;
-  });
-
-  int c = adaptive_spin_count;
+  if (adaptive_spin_count_.load(std::memory_order_relaxed) == 0) {
+    int current_spin_count = 0;
+    int new_spin_count = NumCPUs() > 1 ? 1000 : 1;
+    // If this fails, the value will remain unchanged. We may not spin for the
+    // intended duration, but that is still safe. We will try again on the next
+    // call to SpinLoop.
+    adaptive_spin_count_.compare_exchange_weak(
+        current_spin_count, new_spin_count, std::memory_order_relaxed,
+        std::memory_order_relaxed);
+  }
+  int c = adaptive_spin_count_.load(std::memory_order_relaxed);
   uint32_t lock_value;
   do {
     lock_value = lockword_.load(std::memory_order_relaxed);
@@ -100,11 +102,11 @@ void SpinLock::SlowLock() {
     return;
   }
 
-  base_internal::SchedulingMode scheduling_mode;
+  SchedulingMode scheduling_mode;
   if ((lock_value & kSpinLockCooperative) != 0) {
-    scheduling_mode = base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
+    scheduling_mode = SCHEDULE_COOPERATIVE_AND_KERNEL;
   } else {
-    scheduling_mode = base_internal::SCHEDULE_KERNEL_ONLY;
+    scheduling_mode = SCHEDULE_KERNEL_ONLY;
   }
 
   // The lock was not obtained initially, so this thread needs to wait for
@@ -134,7 +136,7 @@ void SpinLock::SlowLock() {
         // new lock state will be the number of cycles this thread waited if
         // this thread obtains the lock.
         lock_value = TryLockInternal(lock_value, wait_cycles);
-        continue;   // Skip the delay at the end of the loop.
+        continue;  // Skip the delay at the end of the loop.
       } else if ((lock_value & kWaitTimeMask) == 0) {
         // The lock is still held, without a waiter being marked, but something
         // else about the lock word changed, causing our CAS to fail. For
@@ -150,8 +152,8 @@ void SpinLock::SlowLock() {
     // synchronization there to avoid false positives.
     ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
     // Wait for an OS specific delay.
-    base_internal::SpinLockDelay(&lockword_, lock_value, ++lock_wait_call_count,
-                                 scheduling_mode);
+    SpinLockDelay(&lockword_, lock_value, ++lock_wait_call_count,
+                  scheduling_mode);
     ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
     // Spin again after returning from the wait routine to give this thread
     // some chance of obtaining the lock.
@@ -162,8 +164,8 @@ void SpinLock::SlowLock() {
 }
 
 void SpinLock::SlowUnlock(uint32_t lock_value) {
-  base_internal::SpinLockWake(&lockword_,
-                              false);  // wake waiter if necessary
+  SpinLockWake(&lockword_,
+               false);  // wake waiter if necessary
 
   // If our acquisition was contended, collect contentionz profile info.  We
   // reserve a unitary wait time to represent that a waiter exists without our