ROSE  0.11.98.0
MemoryMap.h
1 #ifndef ROSE_BinaryAnalysis_MemoryMap_H
2 #define ROSE_BinaryAnalysis_MemoryMap_H
3 #include <featureTests.h>
4 #ifdef ROSE_ENABLE_BINARY_ANALYSIS
5 
6 #include <Rose/BinaryAnalysis/BasicTypes.h>
7 
8 #include <ByteOrder.h>
9 #include <Combinatorics.h>
10 #include <Rose/Exception.h>
11 
12 #include <Sawyer/Access.h>
13 #include <Sawyer/AddressMap.h>
14 #include <Sawyer/AllocatingBuffer.h>
15 #include <Sawyer/MappedBuffer.h>
16 #include <Sawyer/NullBuffer.h>
17 #include <Sawyer/Optional.h>
18 #include <Sawyer/StaticBuffer.h>
19 
20 #include <boost/config.hpp>
21 #include <boost/utility/enable_if.hpp>
22 #include <boost/serialization/access.hpp>
23 #include <boost/serialization/base_object.hpp>
24 #include <boost/serialization/export.hpp>
25 #include <boost/type_traits/is_integral.hpp>
26 
27 namespace Rose {
28 namespace BinaryAnalysis {
29 
35 template<typename T, typename U>
36 typename boost::enable_if_c<boost::is_integral<T>::value && boost::is_integral<U>::value, T>::type
37 alignUp(T address, U alignment) {
38  ASSERT_require(alignment > 0);
39  T almt = static_cast<T>(alignment);
40  return ((address + almt - 1) / almt) * almt;
41 }
42 
48 template<typename T, typename U>
49 typename boost::enable_if_c<boost::is_integral<T>::value && boost::is_integral<U>::value, T>::type
50 alignDown(T address, U alignment) {
51  ASSERT_require(alignment > 0);
52  T almt = static_cast<T>(alignment);
53  return (address / almt) * almt;
54 }
55 
112 class MemoryMap: public Sawyer::Container::AddressMap<rose_addr_t, uint8_t>, public Sawyer::SharedObject {
113 public:
115  using Ptr = MemoryMapPtr;
116 
117  typedef rose_addr_t Address;
118  typedef uint8_t Value;
128 
130  struct Attach { // For consistency with other <Feature>::Boolean types
131  enum Boolean {
132  NO,
134  };
135  };
136 
137 private:
138  ByteOrder::Endianness endianness_;
139 
140 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
141 private:
142  friend class boost::serialization::access;
143 
144  template<class S>
145  void serialize(S &s, const unsigned /*version*/) {
146  s.template register_type<AllocatingBuffer>();
147  s.template register_type<MappedBuffer>();
148  s.template register_type<NullBuffer>();
149  s.template register_type<StaticBuffer>();
150  s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Super);
151  s & BOOST_SERIALIZATION_NVP(endianness_);
152  }
153 #endif
154 
155 public:
156 
157  // Whoever pollutes all namespaces with these common word preprocessor symbols is a lunatic!
158 # if defined(READABLE) || defined(WRITABLE) || defined(EXECUTABLE) || defined(IMMUTABLE) || defined(PRIVATE)
159 # ifdef _MSC_VER
160 # pragma message("Undefining common words from the global namespace: READABLE, WRITABLE, EXECUTABLE, IMMUTABLE, PRIVATE")
161 # else
162 # warning "Undefining common words from the global namespace: READABLE, WRITABLE, EXECUTABLE, IMMUTABLE, PRIVATE"
163 # endif
164 # undef READABLE
165 # undef WRITABLE
166 # undef EXECUTABLE
167 # undef IMMUTABLE
168 # undef PRIVATE
169 # endif
170 
171  // Accessibility flags
172  static const unsigned NO_ACCESS = 0;
173  static const unsigned READABLE = Sawyer::Access::READABLE;
174  static const unsigned WRITABLE = Sawyer::Access::WRITABLE;
175  static const unsigned EXECUTABLE = Sawyer::Access::EXECUTABLE;
176  static const unsigned IMMUTABLE = Sawyer::Access::IMMUTABLE;
177  static const unsigned PRIVATE = Sawyer::Access::PRIVATE;
178  static const unsigned INITIALIZED = 0x00000200; // Partitioner2: initialized memory even if writable
179 
180  // Aggregate accessibility flags
181  static const unsigned READ_WRITE = READABLE | WRITABLE;
182  static const unsigned READ_EXECUTE = READABLE | EXECUTABLE;
183  static const unsigned READ_WRITE_EXECUTE = READABLE | WRITABLE | EXECUTABLE;
184 
185  // These bits are reserved for use in ROSE
186  static const unsigned RESERVED_ACCESS_BITS = 0x0000ffff;
187 
188 
189 public:
191  class Exception: public Rose::Exception {
192  public:
193  Exception(const std::string &mesg, const MemoryMap::Ptr map): Rose::Exception(mesg), map(map) {}
194  virtual ~Exception() throw() {}
195  virtual std::string leader(std::string dflt="memory map problem") const;
196  virtual std::string details(bool) const;
197  virtual void print(std::ostream&, bool verbose=true) const;
198  friend std::ostream& operator<<(std::ostream&, const Exception&);
199  public:
201  };
202 
207  struct Inconsistent : public Exception {
208  Inconsistent(const std::string &mesg, const MemoryMap::Ptr &map,
209  const AddressInterval &new_range, const Segment &new_segment,
210  const AddressInterval &old_range, const Segment &old_segment)
211  : Exception(mesg, map),
212  new_range(new_range), old_range(old_range),
213  new_segment(new_segment), old_segment(old_segment) {}
214  virtual ~Inconsistent() throw() {}
215  virtual void print(std::ostream&, bool verbose=true) const;
216  friend std::ostream& operator<<(std::ostream&, const Inconsistent&);
217  AddressInterval new_range, old_range;
218  Segment new_segment, old_segment;
219  };
220 
222  struct NotMapped : public Exception {
223  NotMapped(const std::string &mesg, const MemoryMap::Ptr &map, rose_addr_t va)
224  : Exception(mesg, map), va(va) {}
225  virtual ~NotMapped() throw() {}
226  virtual void print(std::ostream&, bool verbose=true) const;
227  friend std::ostream& operator<<(std::ostream&, const NotMapped&);
228  rose_addr_t va;
229  };
230 
232  struct NoFreeSpace : public Exception {
233  NoFreeSpace(const std::string &mesg, const MemoryMap::Ptr &map, size_t size)
234  : Exception(mesg, map), size(size) {}
235  virtual ~NoFreeSpace() throw() {}
236  virtual void print(std::ostream&, bool verbose=true) const;
237  friend std::ostream& operator<<(std::ostream&, const NoFreeSpace&);
238  size_t size;
239  };
240 
242  struct SyntaxError: public Exception {
243  SyntaxError(const std::string &mesg, const MemoryMap::Ptr &map, const std::string &filename,
244  unsigned linenum, int colnum=-1)
245  : Exception(mesg, map), filename(filename), linenum(linenum), colnum(colnum) {}
246  virtual ~SyntaxError() throw() {}
247  virtual void print(std::ostream&, bool verbose=true) const;
248  friend std::ostream& operator<<(std::ostream&, const SyntaxError&);
249  std::string filename;
250  unsigned linenum;
251  int colnum;
252  };
253 
254 protected:
256  MemoryMap(): endianness_(ByteOrder::ORDER_UNSPECIFIED) {}
257 
258 public:
260  static Ptr instance() {
261  return Ptr(new MemoryMap);
262  }
263 
268  return Ptr(new MemoryMap(*this));
269  }
270 
278  ByteOrder::Endianness byteOrder() const { return endianness_; }
279  void byteOrder(ByteOrder::Endianness order) { endianness_ = order; }
282  // Note that the order of the enum members is for backward compatibility with an older version of insertFile whose third
283  // argument was "bool writable = false" (MAP_RDONLY, but now intended to be MAP_PRIVATE) and when it was true was the same
284  // as MAP_READWRITE.
285  //
294  };
295 
300  size_t insertFile(const std::string &fileName, rose_addr_t va, InsertFileMapMode mode = MAP_PRIVATE,
301  std::string segmentName = "");
302 
378  AddressInterval insertFile(const std::string &locatorString);
379 
381  static std::string insertFileDocumentation();
382 
409  AddressInterval insertData(const std::string &locatorString);
410 
412  static std::string insertDataDocumentation();
413 
418  void adjustMap(const std::string &locatorString);
419 
421  static std::string adjustMapDocumentation();
422 
423 
426  AddressInterval interval;
427  unsigned accessibility;
428  rose_addr_t fileOffset;
429  std::string deviceName;
430  size_t inode;
431  std::string comment;
434  : accessibility(0), fileOffset(0), inode(0) {}
435  };
436 
440  static std::vector<ProcessMapRecord> readProcessMap(pid_t);
441 
442 #ifdef BOOST_WINDOWS
443  void insertProcess(int pid, Attach::Boolean attach);
444 #else
445 
446  void insertProcess(pid_t pid, Attach::Boolean attach);
447 #endif
448 
452  void insertProcess(const std::string &locatorString);
453 
457  bool insertProcessPid(pid_t, const AddressInterval &where, unsigned accessibility, const std::string &name);
458  void insertProcessPid(pid_t, const std::vector<ProcessMapRecord>&);
459  bool insertProcessMemory(int memFile, const AddressInterval &where, unsigned accessibility, std::string name);
463  static std::string insertProcessDocumentation();
464 
468  void linkTo(const MemoryMap::Ptr &other, const AddressIntervalSet &parts);
469 
475  static std::pair<Buffer::Ptr, std::string> copyFromFile(int fd, const AddressInterval&);
476 
478  void eraseZeros(size_t minsize);
479 
490  bool shrinkUnshare();
491 
493  size_t readQuick(void *buf, rose_addr_t startVa, size_t desired) const {
494  return at(startVa).limit(desired).require(READABLE).read((uint8_t*)buf).size();
495  }
496 
509  std::string readString(rose_addr_t startVa, size_t desired, int(*validChar)(int)=NULL, int(*invalidChar)(int)=NULL,
510  unsigned requiredPerms=READABLE, unsigned prohibitedPerms=0, char terminator='\0') const;
511 
517  template<typename U>
518  Sawyer::Optional<U> readUnsigned(rose_addr_t startVa) const {
519  U val = 0;
520  if (at(startVa).limit(sizeof val).read((uint8_t*)&val).size() != sizeof val)
521  return Sawyer::Nothing();
522  ByteOrder::convert((void*)&val, sizeof val, endianness_, ByteOrder::host_order());
523  return val;
524  }
525 
531  Sawyer::Optional<uint64_t> readLongUnsinged(rose_addr_t startVa) const {
532  uint64_t val = 0;
533  if (at(startVa).limit(sizeof val).read((uint8_t*)&val).size() != sizeof val)
534  return Sawyer::Nothing();
535  ByteOrder::convert((void*)&val, sizeof val, endianness_, ByteOrder::host_order());
536  return val;
537  }
538 
543  size_t writeUnsigned(uint32_t value, rose_addr_t startVa) {
544  return at(startVa).limit(sizeof(uint32_t)).write((const uint8_t*)(&value)).size();
545  }
546 
551  size_t writeUnsigned(uint64_t value, rose_addr_t startVa) {
552  return at(startVa).limit(sizeof(uint64_t)).write((const uint8_t*)(&value)).size();
553  }
554 
558  Sawyer::Optional<uint8_t> readByte(rose_addr_t) const;
559 
561  SgUnsignedCharList readVector(rose_addr_t startVa, size_t desired, unsigned requiredPerms=READABLE) const;
562 
564  size_t writeQuick(const void *buf, rose_addr_t startVa, size_t desired) {
565  return at(startVa).limit(desired).require(WRITABLE).write((const uint8_t*)buf).size();
566  }
567 
575  Sawyer::Optional<rose_addr_t> findAny(const Extent &limits, const std::vector<uint8_t> &bytesToFind,
576  unsigned requiredPerms=READABLE, unsigned prohibitedPerms=0) const;
577  Sawyer::Optional<rose_addr_t> findAny(const AddressInterval &limits, const std::vector<uint8_t> &bytesToFind,
578  unsigned requiredPerms=READABLE, unsigned prohibitedPerms=0) const;
586  Sawyer::Optional<rose_addr_t> findSequence(const AddressInterval &interval, const std::vector<uint8_t> &sequence) const;
587 
591  void dump(FILE*, const char *prefix="") const;
592  void dump(std::ostream&, std::string prefix="") const;
593  void print(std::ostream &o, std::string prefix="") const { dump(o, prefix); }
594  void dump() const; // mostly for calling from within GDB or similar
612 
614  static std::string segmentTitle(const Segment&);
615 
616  friend std::ostream& operator<<(std::ostream&, const MemoryMap&);
617 };
618 
619 } // namespace
620 } // namespace
621 
622 // Register the types needed for serialization since some of them are derived from polymorphic class templates.
623 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
625 BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::MemoryMap::MappedBuffer);
626 BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::MemoryMap::NullBuffer);
627 BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::MemoryMap::StaticBuffer);
628 #endif
629 
630 #endif
631 #endif
Exception thrown by find_free() when there's not enough free space left.
Definition: MemoryMap.h:232
int colnum
Optional column number (0-origin; negative if unknown).
Definition: MemoryMap.h:251
Sawyer::Optional< uint8_t > readByte(rose_addr_t) const
Read a byte from memory.
Sawyer::Optional< uint64_t > readLongUnsinged(rose_addr_t startVa) const
Read a long unsigned value.
Definition: MemoryMap.h:531
Points to static data.
Definition: StaticBuffer.h:30
static std::string adjustMapDocumentation()
Documentation string for adjustMap.
Exception thrown by load() when there's a syntax error in the index file.
Definition: MemoryMap.h:242
virtual std::string leader(std::string dflt="memory map problem") const
Leading part of the error message.
static std::pair< Buffer::Ptr, std::string > copyFromFile(int fd, const AddressInterval &)
Copy part of a file into a buffer.
void print(std::ostream &o, std::string prefix="") const
Prints the contents of the map for debugging.
Definition: MemoryMap.h:593
virtual std::string details(bool) const
Details emitted on following lines, indented two spaces.
AddressMapConstraints< const AddressMap > at(Address x) const
Constraint: anchor point.
Definition: AddressMap.h:1115
static std::string insertFileDocumentation()
Documentation string for insertFile.
size_t insertFile(const std::string &fileName, rose_addr_t va, InsertFileMapMode mode=MAP_PRIVATE, std::string segmentName="")
Insert file contents into memory map.
A contiguous range of values.
Definition: rangemap.h:50
InsertFileMapMode
Mapping mode for insertFile.
Definition: MemoryMap.h:287
rose_addr_t fileOffset
The accessibility flags.
Definition: MemoryMap.h:428
MemoryMap()
Constructs an empty memory map.
Definition: MemoryMap.h:256
Holds a value or nothing.
Definition: Optional.h:49
MemoryMap::Ptr map
Map that caused the exception if available, null otherwise.
Definition: MemoryMap.h:200
Attach with ptrace, get memory, then detach.
Definition: MemoryMap.h:133
AddressSegment< rose_addr_t, uint8_t > Segment
Type of segments stored by this map.
Definition: AddressMap.h:1011
AddressInterval insertData(const std::string &locatorString)
Insert data into a memory map.
Main namespace for the ROSE library.
Information about a process map.
Definition: MemoryMap.h:425
Memory mapped file.
Definition: MappedBuffer.h:43
File is mapped with read-only permission.
Definition: MemoryMap.h:292
Reference-counting intrusive smart pointer.
Definition: SharedPointer.h:68
Allocates memory as needed.
std::string filename
Name of index file where error occurred.
Definition: MemoryMap.h:249
Combinatorics::Hasher & hash(Combinatorics::Hasher &) const
Compute a hash of the entire memory contents.
MemoryMapPtr Ptr
Reference counting pointer.
Definition: MemoryMap.h:115
static Ptr instance()
Construct an empty memory map.
Definition: MemoryMap.h:260
void byteOrder(ByteOrder::Endianness order)
Property: byte order.
Definition: MemoryMap.h:279
Sawyer::Container::Interval< Address > read(Value *buf, const AddressMapConstraints< const AddressMap > &c, MatchFlags flags=0) const
Reads data into the supplied buffer.
Definition: AddressMap.h:1690
File is mapped with read and write permission.
Definition: MemoryMap.h:290
size_t readQuick(void *buf, rose_addr_t startVa, size_t desired) const
Read data into buffer.
Definition: MemoryMap.h:493
void insertProcess(pid_t pid, Attach::Boolean attach)
Insert the memory of some other process into this memory map.
size_t inode
The device from which the data is mapped, or "00:00".
Definition: MemoryMap.h:430
Exception for when we try to access a virtual address that isn't mapped.
Definition: MemoryMap.h:222
A mapping from address space to values.
Definition: AddressMap.h:1004
unsigned accessibility
Mapped virtual addresses.
Definition: MemoryMap.h:427
Buffer that has no data.
Definition: NullBuffer.h:26
Base class for all buffers.
Definition: Buffer.h:25
An efficient mapping from an address space to stored data.
Definition: MemoryMap.h:112
size_t writeUnsigned(uint32_t value, rose_addr_t startVa)
Write an unsigned value.
Definition: MemoryMap.h:543
bool insertProcessMemory(int memFile, const AddressInterval &where, unsigned accessibility, std::string name)
Insert part of another process's memory into this memory map.
unsigned linenum
Line number (1 origin) where error occurred.
Definition: MemoryMap.h:250
Binary analysis.
Constraints are used to select addresses from a memory map.
Definition: AddressMap.h:80
Sawyer::Optional< rose_addr_t > findSequence(const AddressInterval &interval, const std::vector< uint8_t > &sequence) const
Search for a byte sequence.
void adjustMap(const std::string &locatorString)
Adjusts a memory map according to the locator string.
static std::vector< ProcessMapRecord > readProcessMap(pid_t)
Obtain the memory map information for a process.
void linkTo(const MemoryMap::Ptr &other, const AddressIntervalSet &parts)
Insert part of another map by reference.
std::string readString(rose_addr_t startVa, size_t desired, int(*validChar)(int)=NULL, int(*invalidChar)(int)=NULL, unsigned requiredPerms=READABLE, unsigned prohibitedPerms=0, char terminator='\0') const
Reads a NUL-terminated string from the memory map.
Base class for reference counted objects.
Definition: SharedObject.h:64
Exception for an inconsistent mapping.
Definition: MemoryMap.h:207
std::string deviceName
Starting byte offset in the file.
Definition: MemoryMap.h:429
size_t writeUnsigned(uint64_t value, rose_addr_t startVa)
Write a long unsigned value.
Definition: MemoryMap.h:551
void eraseZeros(size_t minsize)
Erases regions of zero bytes that are executable and readable and at least minsize in size...
bool insertProcessPid(pid_t, const AddressInterval &where, unsigned accessibility, const std::string &name)
Insert part of another process's memory into this memory map.
SgUnsignedCharList readVector(rose_addr_t startVa, size_t desired, unsigned requiredPerms=READABLE) const
Read quickly into a vector.
Attach with ptrace first when reading a process?
Definition: MemoryMap.h:130
std::string comment
Inode on the device, or zero.
Definition: MemoryMap.h:431
bool shrinkUnshare()
Shrink buffers and remove sharing.
Represents no value.
Definition: Optional.h:32
ByteOrder::Endianness byteOrder() const
Property: byte order.
Definition: MemoryMap.h:278
void dump() const
Prints the contents of the map for debugging.
static std::string insertDataDocumentation()
Documentation string for insertData.
Sawyer::Optional< rose_addr_t > findAny(const Extent &limits, const std::vector< uint8_t > &bytesToFind, unsigned requiredPerms=READABLE, unsigned prohibitedPerms=0) const
Search for any byte.
static std::string segmentTitle(const Segment &)
Title of a segment when printing the map.
Base class for all ROSE exceptions.
Definition: Rose/Exception.h:9
static std::string insertProcessDocumentation()
Documentation string for insertProcess.
AddressMapConstraints< const AddressMap > limit(size_t x) const
Constraint: limit matched size.
Definition: AddressMap.h:1156
size_t writeQuick(const void *buf, rose_addr_t startVa, size_t desired)
Write data from buffer.
Definition: MemoryMap.h:564
Sawyer::Optional< U > readUnsigned(rose_addr_t startVa) const
Read an unsigned value.
Definition: MemoryMap.h:518
Exception for MemoryMap operations.
Definition: MemoryMap.h:191
Assume ptrace is attached and process is stopped.
Definition: MemoryMap.h:132
Ptr shallowCopy()
Create a new copy of the memory map.
Definition: MemoryMap.h:267