Home | History | Annotate | Download | only in backtrace 
      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   typedef std::deque<backtrace_map_t>::iterator iterator;
     75   iterator begin() { return maps_.begin(); }
     76   iterator end() { return maps_.end(); }
     77 
     78   typedef std::deque<backtrace_map_t>::const_iterator const_iterator;
     79   const_iterator begin() const { return maps_.begin(); }
     80   const_iterator end() const { return maps_.end(); }
     81 
     82   virtual bool Build();
     83 
     84   static inline bool IsValid(const backtrace_map_t& map) {
     85     return map.end > 0;
     86   }
     87 
     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