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 
35 struct backtrace_map_t {
36   uintptr_t start = 0;
37   uintptr_t end = 0;
38   uintptr_t offset = 0;
39   uintptr_t load_base = 0;
40   int flags = 0;
41   std::string name;
42 };
43 
44 class BacktraceMap {
45 public:
46   // If uncached is true, then parse the current process map as of the call.
47   // Passing a map created with uncached set to true to Backtrace::Create()
48   // is unsupported.
49   static BacktraceMap* Create(pid_t pid, bool uncached = false);
50 
51   virtual ~BacktraceMap();
52 
53   // Fill in the map data structure for the given address.
54   virtual void FillIn(uintptr_t addr, backtrace_map_t* map);
55 
56   // The flags returned are the same flags as used by the mmap call.
57   // The values are PROT_*.
GetFlags(uintptr_t pc)58   int GetFlags(uintptr_t pc) {
59     backtrace_map_t map;
60     FillIn(pc, &map);
61     if (IsValid(map)) {
62       return map.flags;
63     }
64     return PROT_NONE;
65   }
66 
IsReadable(uintptr_t pc)67   bool IsReadable(uintptr_t pc) { return GetFlags(pc) & PROT_READ; }
IsWritable(uintptr_t pc)68   bool IsWritable(uintptr_t pc) { return GetFlags(pc) & PROT_WRITE; }
IsExecutable(uintptr_t pc)69   bool IsExecutable(uintptr_t pc) { return GetFlags(pc) & PROT_EXEC; }
70 
71   typedef std::deque<backtrace_map_t>::iterator iterator;
begin()72   iterator begin() { return maps_.begin(); }
end()73   iterator end() { return maps_.end(); }
74 
75   typedef std::deque<backtrace_map_t>::const_iterator const_iterator;
begin()76   const_iterator begin() const { return maps_.begin(); }
end()77   const_iterator end() const { return maps_.end(); }
78 
79   virtual bool Build();
80 
IsValid(const backtrace_map_t & map)81   static inline bool IsValid(const backtrace_map_t& map) {
82     return map.end > 0;
83   }
84 
GetRelativePc(const backtrace_map_t & map,uintptr_t pc)85   static uintptr_t GetRelativePc(const backtrace_map_t& map, uintptr_t pc) {
86     if (IsValid(map)) {
87       return pc - map.start + map.load_base;
88     } else {
89       return pc;
90     }
91   }
92 
93 protected:
94   BacktraceMap(pid_t pid);
95 
96   virtual bool ParseLine(const char* line, backtrace_map_t* map);
97 
98   std::deque<backtrace_map_t> maps_;
99   pid_t pid_;
100 };
101 
102 #endif // _BACKTRACE_BACKTRACE_MAP_H
103