grpc 1.52.2 → 1.53.0.pre2

data/third_party/abseil-cpp/absl/debugging/internal/stacktrace_riscv-inl.inc

@@ -30,56 +30,14 @@
 #include <cassert>
 #include <cstdint>
 #include <iostream>
+#include <limits>
+#include <utility>
 
 #include "absl/base/attributes.h"
-#include "absl/debugging/internal/address_is_readable.h"
-#include "absl/debugging/internal/vdso_support.h"
 #include "absl/debugging/stacktrace.h"
 
 static const uintptr_t kUnknownFrameSize = 0;
 
-#if defined(__linux__)
-// Returns the address of the VDSO __kernel_rt_sigreturn function, if present.
-static const unsigned char *GetKernelRtSigreturnAddress() {
-  constexpr uintptr_t kImpossibleAddress = 0;
-  ABSL_CONST_INIT static std::atomic<uintptr_t> memoized(kImpossibleAddress);
-  uintptr_t address = memoized.load(std::memory_order_relaxed);
-  if (address != kImpossibleAddress) {
-    return reinterpret_cast<const unsigned char *>(address);
-  }
-
-  address = reinterpret_cast<uintptr_t>(nullptr);
-
-#if ABSL_HAVE_VDSO_SUPPORT
-  absl::debugging_internal::VDSOSupport vdso;
-  if (vdso.IsPresent()) {
-    absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info;
-    // Symbol versioning pulled from arch/riscv/kernel/vdso/vdso.lds at v5.10.
-    auto lookup = [&](int type) {
-      return vdso.LookupSymbol("__vdso_rt_sigreturn", "LINUX_4.15", type,
-                               &symbol_info);
-    };
-    if ((!lookup(STT_FUNC) && !lookup(STT_NOTYPE)) ||
-        symbol_info.address == nullptr) {
-      // Unexpected: VDSO is present, yet the expected symbol is missing or
-      // null.
-      assert(false && "VDSO is present, but doesn't have expected symbol");
-    } else {
-      if (reinterpret_cast<uintptr_t>(symbol_info.address) !=
-          kImpossibleAddress) {
-        address = reinterpret_cast<uintptr_t>(symbol_info.address);
-      } else {
-        assert(false && "VDSO returned invalid address");
-      }
-    }
-  }
-#endif
-
-  memoized.store(address, std::memory_order_relaxed);
-  return reinterpret_cast<const unsigned char *>(address);
-}
-#endif  // __linux__
-
 // Compute the size of a stack frame in [low..high).  We assume that low < high.
 // Return size of kUnknownFrameSize.
 template <typename T>
@@ -96,7 +54,8 @@ static inline uintptr_t ComputeStackFrameSize(const T *low, const T *high) {
 template <bool STRICT_UNWINDING, bool WITH_CONTEXT>
 ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS  // May read random elements from stack.
 ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY   // May read random elements from stack.
-static void ** NextStackFrame(void **old_frame_pointer, const void *uc) {
+static void ** NextStackFrame(void **old_frame_pointer, const void *uc,
+                              const std::pair<size_t, size_t> range) {
   //               .
   //               .
   //               .
@@ -114,55 +73,43 @@ static void ** NextStackFrame(void **old_frame_pointer, const void *uc) {
   // $sp ->|      ...       |
   //       +----------------+
   void **new_frame_pointer = reinterpret_cast<void **>(old_frame_pointer[-2]);
-  bool check_frame_size = true;
-
-#if defined(__linux__)
-  if (WITH_CONTEXT && uc != nullptr) {
-    // Check to see if next frame's return address is __kernel_rt_sigreturn.
-    if (old_frame_pointer[-1] == GetKernelRtSigreturnAddress()) {
-      const ucontext_t *ucv = static_cast<const ucontext_t *>(uc);
-      // old_frame_pointer is not suitable for unwinding, look at ucontext to
-      // discover frame pointer before signal.
-      //
-      // RISCV ELF psABI has the frame pointer at x8/fp/s0.
-      // -- RISCV psABI Table 18.2
-      void **const pre_signal_frame_pointer =
-          reinterpret_cast<void **>(ucv->uc_mcontext.__gregs[8]);
-
-      // Check the alleged frame pointer is actually readable. This is to
-      // prevent "double fault" in case we hit the first fault due to stack
-      // corruption.
-      if (!absl::debugging_internal::AddressIsReadable(
-              pre_signal_frame_pointer))
-        return nullptr;
-
-      // Alleged frame pointer is readable, use it for further unwinding.
-      new_frame_pointer = pre_signal_frame_pointer;
-
-      // Skip frame size check if we return from a signal.  We may be using an
-      // alterate stack for signals.
-      check_frame_size = false;
-    }
-  }
-#endif
+  uintptr_t frame_pointer = reinterpret_cast<uintptr_t>(new_frame_pointer);
 
   // The RISCV ELF psABI mandates that the stack pointer is always 16-byte
   // aligned.
-  // FIXME(abdulras) this doesn't hold for ILP32E which only mandates a 4-byte
+  // TODO(#1236) this doesn't hold for ILP32E which only mandates a 4-byte
   // alignment.
-  if ((reinterpret_cast<uintptr_t>(new_frame_pointer) & 15) != 0)
+  if (frame_pointer & 15)
     return nullptr;
 
+  // If the new frame pointer matches the signal context, avoid terminating
+  // early to deal with alternate signal stacks.
+  if (WITH_CONTEXT)
+    if (const ucontext_t *ucv = static_cast<const ucontext_t *>(uc))
+      // RISCV ELF psABI has the frame pointer at x8/fp/s0.
+      // -- RISCV psABI Table 18.2
+      if (ucv->uc_mcontext.__gregs[8] == frame_pointer)
+        return new_frame_pointer;
+
   // Check frame size.  In strict mode, we assume frames to be under 100,000
   // bytes.  In non-strict mode, we relax the limit to 1MB.
-  if (check_frame_size) {
-    const uintptr_t max_size = STRICT_UNWINDING ? 100000 : 1000000;
-    const uintptr_t frame_size =
-        ComputeStackFrameSize(old_frame_pointer, new_frame_pointer);
-    if (frame_size == kUnknownFrameSize || frame_size > max_size)
+  const uintptr_t max_size = STRICT_UNWINDING ? 100000 : 1000000;
+  const uintptr_t frame_size =
+      ComputeStackFrameSize(old_frame_pointer, new_frame_pointer);
+  if (frame_size == kUnknownFrameSize) {
+    if (STRICT_UNWINDING)
+      return nullptr;
+
+    // In non-strict mode permit non-contiguous stacks (e.g. alternate signal
+    // frame handling).
+    if (reinterpret_cast<uintptr_t>(new_frame_pointer) < range.first ||
+        reinterpret_cast<uintptr_t>(new_frame_pointer) > range.second)
       return nullptr;
   }
 
+  if (frame_size > max_size)
+    return nullptr;
+
   return new_frame_pointer;
 }
 
@@ -180,6 +127,12 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
 #error reading stack pointer not yet supported on this platform
 #endif
 
+  std::pair<size_t, size_t> stack = {
+      // assume that the first page is not the stack.
+      static_cast<size_t>(sysconf(_SC_PAGESIZE)),
+      std::numeric_limits<size_t>::max() - sizeof(void *)
+  };
+
   int n = 0;
   void *return_address = nullptr;
   while (frame_pointer && n < max_depth) {
@@ -190,7 +143,8 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
     // non-strict unwinding rules to produce a stack trace that is as complete
     // as possible (even if it contains a few bogus entries in some rare cases).
     void **next_frame_pointer =
-        NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
+        NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp,
+                                                          stack);
 
     if (skip_count > 0) {
       skip_count--;
@@ -217,7 +171,8 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
         num_dropped_frames++;
       }
       frame_pointer =
-          NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
+          NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp,
+                                                            stack);
     }
     *min_dropped_frames = num_dropped_frames;
   }

data/third_party/abseil-cpp/absl/debugging/internal/stacktrace_win32-inl.inc

@@ -63,11 +63,12 @@ static RtlCaptureStackBackTrace_Function* const RtlCaptureStackBackTrace_fn =
 template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
 static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
                       const void*, int* min_dropped_frames) {
-  int n = 0;
-  if (!RtlCaptureStackBackTrace_fn) {
-    // can't find a stacktrace with no function to call
+  USHORT n = 0;
+  if (!RtlCaptureStackBackTrace_fn || skip_count < 0 || max_depth < 0) {
+    // can't get a stacktrace with no function/invalid args
   } else {
-    n = (int)RtlCaptureStackBackTrace_fn(skip_count + 2, max_depth, result, 0);
+    n = RtlCaptureStackBackTrace_fn(static_cast<ULONG>(skip_count) + 2,
+                                    static_cast<ULONG>(max_depth), result, 0);
   }
   if (IS_STACK_FRAMES) {
     // No implementation for finding out the stack frame sizes yet.

data/third_party/abseil-cpp/absl/debugging/internal/stacktrace_x86-inl.inc

@@ -29,14 +29,13 @@
 #include <cstdint>
 #include <limits>
 
+#include "absl/base/attributes.h"
 #include "absl/base/macros.h"
 #include "absl/base/port.h"
 #include "absl/debugging/internal/address_is_readable.h"
 #include "absl/debugging/internal/vdso_support.h"  // a no-op on non-elf or non-glibc systems
 #include "absl/debugging/stacktrace.h"
 
-#include "absl/base/internal/raw_logging.h"
-
 using absl::debugging_internal::AddressIsReadable;
 
 #if defined(__linux__) && defined(__i386__)
@@ -113,6 +112,10 @@ static int CountPushInstructions(const unsigned char *const addr) {
 
 // Assume stack frames larger than 100,000 bytes are bogus.
 static const int kMaxFrameBytes = 100000;
+// Stack end to use when we don't know the actual stack end
+// (effectively just the end of address space).
+constexpr uintptr_t kUnknownStackEnd =
+    std::numeric_limits<size_t>::max() - sizeof(void *);
 
 // Returns the stack frame pointer from signal context, 0 if unknown.
 // vuc is a ucontext_t *.  We use void* to avoid the use
@@ -140,13 +143,14 @@ static uintptr_t GetFP(const void *vuc) {
     // TODO(bcmills): -momit-leaf-frame-pointer is currently the default
     // behavior when building with clang.  Talk to the C++ toolchain team about
     // fixing that.
-    if (bp >= sp && bp - sp <= kMaxFrameBytes) return bp;
+    if (bp >= sp && bp - sp <= kMaxFrameBytes)
+      return static_cast<uintptr_t>(bp);
 
     // If bp isn't a plausible frame pointer, return the stack pointer instead.
     // If we're lucky, it points to the start of a stack frame; otherwise, we'll
     // get one frame of garbage in the stack trace and fail the sanity check on
     // the next iteration.
-    return sp;
+    return static_cast<uintptr_t>(sp);
   }
 #endif
   return 0;
@@ -258,8 +262,26 @@ static void **NextStackFrame(void **old_fp, const void *uc,
     // With the stack growing downwards, older stack frame must be
     // at a greater address that the current one.
     if (new_fp_u <= old_fp_u) return nullptr;
-    if (new_fp_u - old_fp_u > kMaxFrameBytes) return nullptr;
 
+    // If we get a very large frame size, it may be an indication that we
+    // guessed frame pointers incorrectly and now risk a paging fault
+    // dereferencing a wrong frame pointer. Or maybe not because large frames
+    // are possible as well. The main stack is assumed to be readable,
+    // so we assume the large frame is legit if we know the real stack bounds
+    // and are within the stack.
+    if (new_fp_u - old_fp_u > kMaxFrameBytes) {
+      if (stack_high < kUnknownStackEnd &&
+          static_cast<size_t>(getpagesize()) < stack_low) {
+        // Stack bounds are known.
+        if (!(stack_low < new_fp_u && new_fp_u <= stack_high)) {
+          // new_fp_u is not within the known stack.
+          return nullptr;
+        }
+      } else {
+        // Stack bounds are unknown, prefer truncated stack to possible crash.
+        return nullptr;
+      }
+    }
     if (stack_low < old_fp_u && old_fp_u <= stack_high) {
       // Old BP was in the expected stack region...
       if (!(stack_low < new_fp_u && new_fp_u <= stack_high)) {
@@ -310,8 +332,9 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
   int n = 0;
   void **fp = reinterpret_cast<void **>(__builtin_frame_address(0));
 
-  size_t stack_low = getpagesize();  // Assume that the first page is not stack.
-  size_t stack_high = std::numeric_limits<size_t>::max() - sizeof(void *);
+  // Assume that the first page is not stack.
+  size_t stack_low = static_cast<size_t>(getpagesize());
+  size_t stack_high = kUnknownStackEnd;
 
   while (fp && n < max_depth) {
     if (*(fp + 1) == reinterpret_cast<void *>(0)) {
@@ -327,7 +350,9 @@ static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
       result[n] = *(fp + 1);
       if (IS_STACK_FRAMES) {
         if (next_fp > fp) {
-          sizes[n] = (uintptr_t)next_fp - (uintptr_t)fp;
+          sizes[n] = static_cast<int>(
+              reinterpret_cast<uintptr_t>(next_fp) -
+              reinterpret_cast<uintptr_t>(fp));
         } else {
           // A frame-size of 0 is used to indicate unknown frame size.
           sizes[n] = 0;

data/third_party/abseil-cpp/absl/debugging/internal/vdso_support.cc

@@ -193,8 +193,9 @@ long VDSOSupport::InitAndGetCPU(unsigned *cpu,  // NOLINT(runtime/int)
 ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
 int GetCPU() {
   unsigned cpu;
-  int ret_code = (*VDSOSupport::getcpu_fn_)(&cpu, nullptr, nullptr);
-  return ret_code == 0 ? cpu : ret_code;
+  long ret_code =  // NOLINT(runtime/int)
+      (*VDSOSupport::getcpu_fn_)(&cpu, nullptr, nullptr);
+  return ret_code == 0 ? static_cast<int>(cpu) : static_cast<int>(ret_code);
 }
 
 }  // namespace debugging_internal

data/third_party/abseil-cpp/absl/debugging/symbolize_darwin.inc

@@ -83,13 +83,14 @@ bool Symbolize(const void* pc, char* out, int out_size) {
       memmove(out, tmp_buf, len + 1);
     }
   } else {
-    strncpy(out, symbol.c_str(), out_size);
+    strncpy(out, symbol.c_str(), static_cast<size_t>(out_size));
   }
 
   if (out[out_size - 1] != '\0') {
     // strncpy() does not '\0' terminate when it truncates.
     static constexpr char kEllipsis[] = "...";
-    int ellipsis_size = std::min<int>(sizeof(kEllipsis) - 1, out_size - 1);
+    size_t ellipsis_size =
+        std::min(sizeof(kEllipsis) - 1, static_cast<size_t>(out_size) - 1);
     memcpy(out + out_size - ellipsis_size - 1, kEllipsis, ellipsis_size);
     out[out_size - 1] = '\0';
   }