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 | 8f2c28d572e08cb456da05d692e41f978c3776b1 (patch) | |
tree | f24d6e2e935760dd877452ad81f8f4c0fc2a97d3 /libbacktrace/include/backtrace/BacktraceMap.h | |
parent | a4b40020ef5ae339e19b832f441c26b598f6c4aa (diff) | |
download | system_core-8f2c28d572e08cb456da05d692e41f978c3776b1.tar.gz system_core-8f2c28d572e08cb456da05d692e41f978c3776b1.tar.bz2 system_core-8f2c28d572e08cb456da05d692e41f978c3776b1.zip |
Moved include/backtrace to libbacktrace/include
Export libbacktrace_headers
Bug: 33241851
Test: Build sailfish
Change-Id: Iba310ffc21d17ba542bed954a960ab305037061c
Diffstat (limited to 'libbacktrace/include/backtrace/BacktraceMap.h')
-rw-r--r-- | libbacktrace/include/backtrace/BacktraceMap.h | 129 |
1 files changed, 129 insertions, 0 deletions
diff --git a/libbacktrace/include/backtrace/BacktraceMap.h b/libbacktrace/include/backtrace/BacktraceMap.h new file mode 100644 index 000000000..8ab0dfabb --- /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 |