102 lines · cpp
1//===-- backtrace_sanitizer_common.cpp --------------------------*- C++ -*-===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include <assert.h>10#include <stddef.h>11#include <stdint.h>12#include <string.h>13 14#include "gwp_asan/optional/backtrace.h"15#include "gwp_asan/options.h"16#include "sanitizer_common/sanitizer_common.h"17#include "sanitizer_common/sanitizer_flag_parser.h"18#include "sanitizer_common/sanitizer_flags.h"19#include "sanitizer_common/sanitizer_stacktrace.h"20 21void __sanitizer::BufferedStackTrace::UnwindImpl(uptr pc, uptr bp,22 void *context,23 bool request_fast,24 u32 max_depth) {25 if (!StackTrace::WillUseFastUnwind(request_fast))26 return Unwind(max_depth, pc, 0, context, 0, 0, false);27 28 uptr top = 0;29 uptr bottom = 0;30 GetThreadStackTopAndBottom(/*at_initialization*/ false, &top, &bottom);31 32 return Unwind(max_depth, pc, bp, context, top, bottom, request_fast);33}34 35namespace {36size_t BacktraceCommon(uintptr_t *TraceBuffer, size_t Size, void *Context) {37 // Use the slow sanitizer unwinder in the segv handler. Fast frame pointer38 // unwinders can end up dropping frames because the kernel sigreturn() frame's39 // return address is the return address at time of fault. This has the result40 // of never actually capturing the PC where the signal was raised.41 bool UseFastUnwind = (Context == nullptr);42 43 __sanitizer::BufferedStackTrace Trace;44 Trace.Reset();45 if (Size > __sanitizer::kStackTraceMax)46 Size = __sanitizer::kStackTraceMax;47 48 Trace.Unwind((__sanitizer::uptr)__builtin_return_address(0),49 (__sanitizer::uptr)__builtin_frame_address(0), Context,50 UseFastUnwind, Size - 1);51 52 memcpy(TraceBuffer, Trace.trace, Trace.size * sizeof(uintptr_t));53 return Trace.size;54}55 56size_t Backtrace(uintptr_t *TraceBuffer, size_t Size) {57 return BacktraceCommon(TraceBuffer, Size, nullptr);58}59 60size_t SegvBacktrace(uintptr_t *TraceBuffer, size_t Size, void *Context) {61 return BacktraceCommon(TraceBuffer, Size, Context);62}63 64static void PrintBacktrace(uintptr_t *Trace, size_t TraceLength,65 gwp_asan::Printf_t Printf) {66 __sanitizer::StackTrace StackTrace;67 StackTrace.trace = reinterpret_cast<__sanitizer::uptr *>(Trace);68 StackTrace.size = TraceLength;69 70 if (StackTrace.size == 0) {71 Printf(" <unknown (does your allocator support backtracing?)>\n\n");72 return;73 }74 75 __sanitizer::InternalScopedString buffer;76 StackTrace.PrintTo(&buffer);77 Printf("%s\n", buffer.data());78}79} // anonymous namespace80 81namespace gwp_asan {82namespace backtrace {83 84// This function is thread-compatible. It must be synchronised in respect to any85// other calls to getBacktraceFunction(), calls to getPrintBacktraceFunction(),86// and calls to either of the functions that they return. Furthermore, this may87// require synchronisation with any calls to sanitizer_common that use flags.88// Generally, this function will be called during the initialisation of the89// allocator, which is done in a thread-compatible manner.90options::Backtrace_t getBacktraceFunction() {91 // The unwinder requires the default flags to be set.92 __sanitizer::SetCommonFlagsDefaults();93 __sanitizer::InitializeCommonFlags();94 return Backtrace;95}96 97PrintBacktrace_t getPrintBacktraceFunction() { return PrintBacktrace; }98SegvBacktrace_t getSegvBacktraceFunction() { return SegvBacktrace; }99 100} // namespace backtrace101} // namespace gwp_asan102