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_*.
GetFlags(uintptr_t pc)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 
IsReadable(uintptr_t pc)70   bool IsReadable(uintptr_t pc) { return GetFlags(pc) & PROT_READ; }
IsWritable(uintptr_t pc)71   bool IsWritable(uintptr_t pc) { return GetFlags(pc) & PROT_WRITE; }
IsExecutable(uintptr_t pc)72   bool IsExecutable(uintptr_t pc) { return GetFlags(pc) & PROT_EXEC; }
73 
74   typedef std::deque<backtrace_map_t>::iterator iterator;
begin()75   iterator begin() { return maps_.begin(); }
end()76   iterator end() { return maps_.end(); }
77 
78   typedef std::deque<backtrace_map_t>::const_iterator const_iterator;
begin()79   const_iterator begin() const { return maps_.begin(); }
end()80   const_iterator end() const { return maps_.end(); }
81 
82   virtual bool Build();
83 
IsValid(const backtrace_map_t & map)84   static inline bool IsValid(const backtrace_map_t& map) {
85     return map.end > 0;
86   }
87 
GetRelativePc(const backtrace_map_t & map,uintptr_t pc)88   static uintptr_t GetRelativePc(const backtrace_map_t& map, uintptr_t pc) {
89     if (IsValid(map)) {
90       return pc - map.start + map.load_base;
91     } else {
92       return pc;
93     }
94   }
95 
96 protected:
97   BacktraceMap(pid_t pid);
98 
99   virtual bool ParseLine(const char* line, backtrace_map_t* map);
100 
101   std::deque<backtrace_map_t> maps_;
102   pid_t pid_;
103 };
104 
105 #endif // _BACKTRACE_BACKTRACE_MAP_H
106