diff options
author | Vijay Venkatraman <vijaykv@google.com> | 2017-04-11 11:22:43 -0700 |
---|---|---|
committer | Vijay Venkatraman <vijaykv@google.com> | 2017-04-11 11:22:43 -0700 |
commit | 7b7446ec952b923900f88fa4399783ac5e7fb56e (patch) | |
tree | c462b2267c84fe1abb154bd5377207895d7be330 | |
parent | f4b1ea9a77dc21ef5bcc69a8b61b53b5b0f11110 (diff) | |
download | unwinding-7b7446ec952b923900f88fa4399783ac5e7fb56e.tar.gz |
Moved include/backtrace to libbacktrace/include
Export libbacktrace_headers
Bug: 33241851
Test: Build sailfish
Change-Id: Iba310ffc21d17ba542bed954a960ab305037061c
-rw-r--r-- | libbacktrace/Android.bp | 7 | ||||
-rw-r--r-- | libbacktrace/include/backtrace/Backtrace.h | 176 | ||||
-rw-r--r-- | libbacktrace/include/backtrace/BacktraceMap.h | 129 | ||||
-rw-r--r-- | libbacktrace/include/backtrace/backtrace_constants.h | 30 |
4 files changed, 342 insertions, 0 deletions
diff --git a/libbacktrace/Android.bp b/libbacktrace/Android.bp index 8f74a1a..7de72a8 100644 --- a/libbacktrace/Android.bp +++ b/libbacktrace/Android.bp @@ -55,6 +55,11 @@ libbacktrace_sources = [ "UnwindPtrace.cpp", ] +cc_library_headers { + name: "libbacktrace_headers", + export_include_dirs: ["include"], +} + cc_library { name: "libbacktrace", defaults: ["libbacktrace_common"], @@ -64,6 +69,8 @@ cc_library { "BacktraceMap.cpp", ], + export_include_dirs: ["include"], + target: { darwin: { enabled: true, diff --git a/libbacktrace/include/backtrace/Backtrace.h b/libbacktrace/include/backtrace/Backtrace.h new file mode 100644 index 0000000..4f73a65 --- /dev/null +++ b/libbacktrace/include/backtrace/Backtrace.h @@ -0,0 +1,176 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * 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 _BACKTRACE_BACKTRACE_H +#define _BACKTRACE_BACKTRACE_H + +#include <inttypes.h> +#include <stdint.h> + +#include <string> +#include <vector> + +#include <backtrace/backtrace_constants.h> +#include <backtrace/BacktraceMap.h> + +#if __LP64__ +#define PRIPTR "016" PRIxPTR +typedef uint64_t word_t; +#else +#define PRIPTR "08" PRIxPTR +typedef uint32_t word_t; +#endif + +enum BacktraceUnwindError : uint32_t { + BACKTRACE_UNWIND_NO_ERROR, + // Something failed while trying to perform the setup to begin the unwind. + BACKTRACE_UNWIND_ERROR_SETUP_FAILED, + // There is no map information to use with the unwind. + BACKTRACE_UNWIND_ERROR_MAP_MISSING, + // An error occurred that indicates a programming error. + BACKTRACE_UNWIND_ERROR_INTERNAL, + // The thread to unwind has disappeared before the unwind can begin. + BACKTRACE_UNWIND_ERROR_THREAD_DOESNT_EXIST, + // The thread to unwind has not responded to a signal in a timely manner. + BACKTRACE_UNWIND_ERROR_THREAD_TIMEOUT, + // Attempt to do an unsupported operation. + BACKTRACE_UNWIND_ERROR_UNSUPPORTED_OPERATION, + // Attempt to do an offline unwind without a context. + BACKTRACE_UNWIND_ERROR_NO_CONTEXT, +}; + +struct backtrace_frame_data_t { + size_t num; // The current fame number. + uintptr_t pc; // The absolute pc. + uintptr_t sp; // The top of the stack. + size_t stack_size; // The size of the stack, zero indicate an unknown stack size. + backtrace_map_t map; // The map associated with the given pc. + std::string func_name; // The function name associated with this pc, NULL if not found. + uintptr_t func_offset; // pc relative to the start of the function, only valid if func_name is not NULL. +}; + +#if defined(__APPLE__) +struct __darwin_ucontext; +typedef __darwin_ucontext ucontext_t; +#else +struct ucontext; +typedef ucontext ucontext_t; +#endif + +struct backtrace_stackinfo_t { + uint64_t start; + uint64_t end; + const uint8_t* data; +}; + +class Backtrace { +public: + // Create the correct Backtrace object based on what is to be unwound. + // If pid < 0 or equals the current pid, then the Backtrace object + // corresponds to the current process. + // If pid < 0 or equals the current pid and tid >= 0, then the Backtrace + // object corresponds to a thread in the current process. + // If pid >= 0 and tid < 0, then the Backtrace object corresponds to a + // different process. + // Tracing a thread in a different process is not supported. + // If map is NULL, then create the map and manage it internally. + // If map is not NULL, the map is still owned by the caller. + static Backtrace* Create(pid_t pid, pid_t tid, BacktraceMap* map = NULL); + + // Create an offline Backtrace object that can be used to do an unwind without a process + // that is still running. If cache_file is set to true, then elf information will be cached + // for this call. The cached information survives until the calling process ends. This means + // that subsequent calls to create offline Backtrace objects will continue to use the same + // cache. It also assumes that the elf files used for each offline unwind are the same. + static Backtrace* CreateOffline(pid_t pid, pid_t tid, BacktraceMap* map, + const backtrace_stackinfo_t& stack, bool cache_file = false); + + virtual ~Backtrace(); + + // Get the current stack trace and store in the backtrace_ structure. + virtual bool Unwind(size_t num_ignore_frames, ucontext_t* context = NULL) = 0; + + // Get the function name and offset into the function given the pc. + // If the string is empty, then no valid function name was found, + // or the pc is not in any valid map. + virtual std::string GetFunctionName(uintptr_t pc, uintptr_t* offset, + const backtrace_map_t* map = NULL); + + // Fill in the map data associated with the given pc. + virtual void FillInMap(uintptr_t pc, backtrace_map_t* map); + + // Read the data at a specific address. + virtual bool ReadWord(uintptr_t ptr, word_t* out_value) = 0; + + // Read arbitrary data from a specific address. If a read request would + // span from one map to another, this call only reads up until the end + // of the current map. + // Returns the total number of bytes actually read. + virtual size_t Read(uintptr_t addr, uint8_t* buffer, size_t bytes) = 0; + + // Create a string representing the formatted line of backtrace information + // for a single frame. + virtual std::string FormatFrameData(size_t frame_num); + virtual std::string FormatFrameData(const backtrace_frame_data_t* frame); + + pid_t Pid() const { return pid_; } + pid_t Tid() const { return tid_; } + size_t NumFrames() const { return frames_.size(); } + + const backtrace_frame_data_t* GetFrame(size_t frame_num) { + if (frame_num >= frames_.size()) { + return NULL; + } + return &frames_[frame_num]; + } + + typedef std::vector<backtrace_frame_data_t>::iterator iterator; + iterator begin() { return frames_.begin(); } + iterator end() { return frames_.end(); } + + typedef std::vector<backtrace_frame_data_t>::const_iterator const_iterator; + const_iterator begin() const { return frames_.begin(); } + const_iterator end() const { return frames_.end(); } + + BacktraceMap* GetMap() { return map_; } + + BacktraceUnwindError GetError() { return error_; } + + std::string GetErrorString(BacktraceUnwindError error); + +protected: + Backtrace(pid_t pid, pid_t tid, BacktraceMap* map); + + // The name returned is not demangled, GetFunctionName() takes care of + // demangling the name. + virtual std::string GetFunctionNameRaw(uintptr_t pc, uintptr_t* offset) = 0; + + virtual bool VerifyReadWordArgs(uintptr_t ptr, word_t* out_value); + + bool BuildMap(); + + pid_t pid_; + pid_t tid_; + + BacktraceMap* map_; + bool map_shared_; + + std::vector<backtrace_frame_data_t> frames_; + + BacktraceUnwindError error_; +}; + +#endif // _BACKTRACE_BACKTRACE_H diff --git a/libbacktrace/include/backtrace/BacktraceMap.h b/libbacktrace/include/backtrace/BacktraceMap.h new file mode 100644 index 0000000..8ab0dfa --- /dev/null +++ b/libbacktrace/include/backtrace/BacktraceMap.h @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * 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 _BACKTRACE_BACKTRACE_MAP_H +#define _BACKTRACE_BACKTRACE_MAP_H + +#include <stdint.h> +#include <sys/types.h> +#ifdef _WIN32 +// MINGW does not define these constants. +#define PROT_NONE 0 +#define PROT_READ 0x1 +#define PROT_WRITE 0x2 +#define PROT_EXEC 0x4 +#else +#include <sys/mman.h> +#endif + +#include <deque> +#include <string> +#include <vector> + +// Special flag to indicate a map is in /dev/. However, a map in +// /dev/ashmem/... does not set this flag. +static constexpr int PROT_DEVICE_MAP = 0x8000; + +struct backtrace_map_t { + uintptr_t start = 0; + uintptr_t end = 0; + uintptr_t offset = 0; + uintptr_t load_base = 0; + int flags = 0; + std::string name; +}; + +class BacktraceMap { +public: + // If uncached is true, then parse the current process map as of the call. + // Passing a map created with uncached set to true to Backtrace::Create() + // is unsupported. + static BacktraceMap* Create(pid_t pid, bool uncached = false); + + static BacktraceMap* Create(pid_t pid, const std::vector<backtrace_map_t>& maps); + + virtual ~BacktraceMap(); + + // Fill in the map data structure for the given address. + virtual void FillIn(uintptr_t addr, backtrace_map_t* map); + + // The flags returned are the same flags as used by the mmap call. + // The values are PROT_*. + int GetFlags(uintptr_t pc) { + backtrace_map_t map; + FillIn(pc, &map); + if (IsValid(map)) { + return map.flags; + } + return PROT_NONE; + } + + bool IsReadable(uintptr_t pc) { return GetFlags(pc) & PROT_READ; } + bool IsWritable(uintptr_t pc) { return GetFlags(pc) & PROT_WRITE; } + bool IsExecutable(uintptr_t pc) { return GetFlags(pc) & PROT_EXEC; } + + // In order to use the iterators on this object, a caller must + // call the LockIterator and UnlockIterator function to guarantee + // that the data does not change while it's being used. + virtual void LockIterator() {} + virtual void UnlockIterator() {} + + typedef std::deque<backtrace_map_t>::iterator iterator; + iterator begin() { return maps_.begin(); } + iterator end() { return maps_.end(); } + + typedef std::deque<backtrace_map_t>::const_iterator const_iterator; + const_iterator begin() const { return maps_.begin(); } + const_iterator end() const { return maps_.end(); } + + virtual bool Build(); + + static inline bool IsValid(const backtrace_map_t& map) { + return map.end > 0; + } + + static uintptr_t GetRelativePc(const backtrace_map_t& map, uintptr_t pc) { + if (IsValid(map)) { + return pc - map.start + map.load_base; + } else { + return pc; + } + } + +protected: + BacktraceMap(pid_t pid); + + virtual bool ParseLine(const char* line, backtrace_map_t* map); + + std::deque<backtrace_map_t> maps_; + pid_t pid_; +}; + +class ScopedBacktraceMapIteratorLock { +public: + explicit ScopedBacktraceMapIteratorLock(BacktraceMap* map) : map_(map) { + map->LockIterator(); + } + + ~ScopedBacktraceMapIteratorLock() { + map_->UnlockIterator(); + } + +private: + BacktraceMap* map_; +}; + +#endif // _BACKTRACE_BACKTRACE_MAP_H diff --git a/libbacktrace/include/backtrace/backtrace_constants.h b/libbacktrace/include/backtrace/backtrace_constants.h new file mode 100644 index 0000000..f8c1575 --- /dev/null +++ b/libbacktrace/include/backtrace/backtrace_constants.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2014 The Android Open Source Project + * + * 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 _BACKTRACE_BACKTRACE_CONSTANTS_H +#define _BACKTRACE_BACKTRACE_CONSTANTS_H + +// When the pid to be traced is set to this value, then trace the current +// process. If the tid value is not BACKTRACE_NO_TID, then the specified +// thread from the current process will be traced. +#define BACKTRACE_CURRENT_PROCESS -1 +// When the tid to be traced is set to this value, then trace the specified +// current thread of the specified pid. +#define BACKTRACE_CURRENT_THREAD -1 + +#define MAX_BACKTRACE_FRAMES 64 + +#endif // _BACKTRACE_BACKTRACE_CONSTANTS_H |