// Copyright 2021 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. #ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_ #define ABSL_DEBUGGING_INTERNAL_STACKTRACE_RISCV_INL_H_ // Generate stack trace for riscv #include <sys/ucontext.h> #include "absl/base/config.h" #if defined(__linux__) #include <sys/mman.h> #include <ucontext.h> #include <unistd.h> #endif #include <atomic> #include <cassert> #include <cstdint> #include <iostream> #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("__kernel_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> static inline uintptr_t ComputeStackFrameSize(const T *low, const T *high) { const char *low_char_ptr = reinterpret_cast<const char *>(low); const char *high_char_ptr = reinterpret_cast<const char *>(high); return low < high ? high_char_ptr - low_char_ptr : kUnknownFrameSize; } // Given a pointer to a stack frame, locate and return the calling stackframe, // or return null if no stackframe can be found. Perform sanity checks (the // strictness of which is controlled by the boolean parameter // "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned. 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) { // . // . // . // +-> +----------------+ // | | return address | // | | previous fp | // | | ... | // | +----------------+ <-+ // | | return address | | // +---|- previous fp | | // | ... | | // $fp ->|----------------+ | // | return address | | // | previous fp -|---+ // $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 // 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 // alignment. if ((reinterpret_cast<uintptr_t>(new_frame_pointer) & 15) != 0) return nullptr; // 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) return nullptr; } return new_frame_pointer; } template <bool IS_STACK_FRAMES, bool IS_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 int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count, const void *ucp, int *min_dropped_frames) { #if defined(__GNUC__) void **frame_pointer = reinterpret_cast<void **>(__builtin_frame_address(0)); #else #error reading stack pointer not yet supported on this platform #endif skip_count++; // Skip the frame for this function. int n = 0; // The `frame_pointer` that is computed here points to the top of the frame. // The two words preceding the address are the return address and the previous // frame pointer. To find a PC value associated with the current frame, we // need to go down a level in the call chain. So we remember the return // address of the last frame seen. This does not work for the first stack // frame, which belongs to `UnwindImp()` but we skip the frame for // `UnwindImp()` anyway. void *prev_return_address = nullptr; while (frame_pointer && n < max_depth) { // The absl::GetStackFrames routine si called when we are in some // informational context (the failure signal handler for example). Use the // 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); if (skip_count > 0) { skip_count--; } else { result[n] = prev_return_address; if (IS_STACK_FRAMES) { sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer); } n++; } prev_return_address = frame_pointer[-1]; frame_pointer = next_frame_pointer; } if (min_dropped_frames != nullptr) { // Implementation detail: we clamp the max of frames we are willing to // count, so as not to spend too much time in the loop below. const int kMaxUnwind = 200; int j = 0; for (; frame_pointer != nullptr && j < kMaxUnwind; j++) { frame_pointer = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp); } *min_dropped_frames = j; } return n; } namespace absl { ABSL_NAMESPACE_BEGIN namespace debugging_internal { bool StackTraceWorksForTest() { return true; } } // namespace debugging_internal ABSL_NAMESPACE_END } // namespace absl #endif