1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef _BACKTRACE_BACKTRACE_MAP_H 18 #define _BACKTRACE_BACKTRACE_MAP_H 19 20 #include <stdint.h> 21 #include <sys/types.h> 22 #ifdef USE_MINGW 23 // MINGW does not define these constants. 24 #define PROT_NONE 0 25 #define PROT_READ 0x1 26 #define PROT_WRITE 0x2 27 #define PROT_EXEC 0x4 28 #else 29 #include <sys/mman.h> 30 #endif 31 32 #include <deque> 33 #include <string> 34 #include <vector> 35 36 struct backtrace_map_t { 37 uintptr_t start = 0; 38 uintptr_t end = 0; 39 uintptr_t offset = 0; 40 uintptr_t load_base = 0; 41 int flags = 0; 42 std::string name; 43 }; 44 45 class BacktraceMap { 46 public: 47 // If uncached is true, then parse the current process map as of the call. 48 // Passing a map created with uncached set to true to Backtrace::Create() 49 // is unsupported. 50 static BacktraceMap* Create(pid_t pid, bool uncached = false); 51 52 static BacktraceMap* Create(pid_t pid, const std::vector<backtrace_map_t>& maps); 53 54 virtual ~BacktraceMap(); 55 56 // Fill in the map data structure for the given address. 57 virtual void FillIn(uintptr_t addr, backtrace_map_t* map); 58 59 // The flags returned are the same flags as used by the mmap call. 60 // The values are PROT_*. 61 int GetFlags(uintptr_t pc) { 62 backtrace_map_t map; 63 FillIn(pc, &map); 64 if (IsValid(map)) { 65 return map.flags; 66 } 67 return PROT_NONE; 68 } 69 70 bool IsReadable(uintptr_t pc) { return GetFlags(pc) & PROT_READ; } 71 bool IsWritable(uintptr_t pc) { return GetFlags(pc) & PROT_WRITE; } 72 bool IsExecutable(uintptr_t pc) { return GetFlags(pc) & PROT_EXEC; } 73 74 // In order to use the iterators on this object, a caller must 75 // call the LockIterator and UnlockIterator function to guarantee 76 // that the data does not change while it's being used. 77 virtual void LockIterator() {} 78 virtual void UnlockIterator() {} 79 80 typedef std::deque<backtrace_map_t>::iterator iterator; 81 iterator begin() { return maps_.begin(); } 82 iterator end() { return maps_.end(); } 83 84 typedef std::deque<backtrace_map_t>::const_iterator const_iterator; 85 const_iterator begin() const { return maps_.begin(); } 86 const_iterator end() const { return maps_.end(); } 87 88 virtual bool Build(); 89 90 static inline bool IsValid(const backtrace_map_t& map) { 91 return map.end > 0; 92 } 93 94 static uintptr_t GetRelativePc(const backtrace_map_t& map, uintptr_t pc) { 95 if (IsValid(map)) { 96 return pc - map.start + map.load_base; 97 } else { 98 return pc; 99 } 100 } 101 102 protected: 103 BacktraceMap(pid_t pid); 104 105 virtual bool ParseLine(const char* line, backtrace_map_t* map); 106 107 std::deque<backtrace_map_t> maps_; 108 pid_t pid_; 109 }; 110 111 class ScopedBacktraceMapIteratorLock { 112 public: 113 explicit ScopedBacktraceMapIteratorLock(BacktraceMap* map) : map_(map) { 114 map->LockIterator(); 115 } 116 117 ~ScopedBacktraceMapIteratorLock() { 118 map_->UnlockIterator(); 119 } 120 121 private: 122 BacktraceMap* map_; 123 }; 124 125 #endif // _BACKTRACE_BACKTRACE_MAP_H 126