Home | History | Annotate | Download | only in quipper 
      1 // Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CHROMIUMOS_WIDE_PROFILING_ADDRESS_MAPPER_H_
      6 #define CHROMIUMOS_WIDE_PROFILING_ADDRESS_MAPPER_H_
      7 
      8 #include <stddef.h>
      9 #include <stdint.h>
     10 
     11 #include <list>
     12 #include <map>
     13 
     14 namespace quipper {
     15 
     16 class AddressMapper {
     17  private:
     18   struct MappedRange;
     19 
     20  public:
     21   AddressMapper() : page_alignment_(0) {}
     22 
     23   // Copy constructor: copies mappings from |source| to this AddressMapper. This
     24   // is useful for copying mappings from parent to child process upon fork(). It
     25   // is also useful to copy kernel mappings to any process that is created.
     26   AddressMapper(const AddressMapper& other);
     27 
     28   typedef std::list<MappedRange> MappingList;
     29 
     30   // Maps a new address range [real_addr, real_addr + length) to quipper space.
     31   // |id| is an identifier value to be stored along with the mapping.
     32   // AddressMapper does not care whether it is unique compared to all other IDs
     33   // passed in. That is up to the caller to keep track of.
     34   // |offset_base| represents the offset within the original region at which the
     35   // mapping begins. The original region can be much larger than the mapped
     36   // region.
     37   // e.g. Given a mapped region with base=0x4000 and size=0x2000 mapped with
     38   // offset_base=0x10000, then the address 0x5000 maps to an offset of 0x11000
     39   // (0x5000 - 0x4000 + 0x10000).
     40   // |remove_existing_mappings| indicates whether to remove old mappings that
     41   // collide with the new range in real address space, indicating it has been
     42   // unmapped.
     43   // Returns true if mapping was successful.
     44   bool MapWithID(const uint64_t real_addr, const uint64_t size,
     45                  const uint64_t id, const uint64_t offset_base,
     46                  bool remove_existing_mappings);
     47 
     48   // Looks up |real_addr| and returns the mapped address and MappingList
     49   // iterator.
     50   bool GetMappedAddressAndListIterator(const uint64_t real_addr,
     51                                        uint64_t* mapped_addr,
     52                                        MappingList::const_iterator* iter) const;
     53 
     54   // Uses MappingList iterator to fetch and return the mapping's ID and offset
     55   // from the start of the mapped space.
     56   // |real_addr_iter| must be valid and not at the end of the list.
     57   void GetMappedIDAndOffset(const uint64_t real_addr,
     58                             MappingList::const_iterator real_addr_iter,
     59                             uint64_t* id, uint64_t* offset) const;
     60 
     61   // Returns true if there are no mappings.
     62   bool IsEmpty() const { return mappings_.empty(); }
     63 
     64   // Returns the number of address ranges that are currently mapped.
     65   size_t GetNumMappedRanges() const { return mappings_.size(); }
     66 
     67   // Returns the maximum length of quipper space containing mapped areas.
     68   // There may be gaps in between blocks.
     69   // If the result is 2^64 (all of quipper space), this returns 0.  Call
     70   // IsEmpty() to distinguish this from actual emptiness.
     71   uint64_t GetMaxMappedLength() const;
     72 
     73   // Sets the page alignment size. Set to 0 to disable page alignment.
     74   // The alignment value must be a power of two. Any other value passed in will
     75   // have no effect. Changing this value in between mappings results in
     76   // undefined behavior.
     77   void set_page_alignment(uint64_t alignment) {
     78     // This also includes the case of 0.
     79     if ((alignment & (alignment - 1)) == 0) page_alignment_ = alignment;
     80   }
     81 
     82   // Dumps the state of the address mapper to logs. Useful for debugging.
     83   void DumpToLog() const;
     84 
     85  private:
     86   typedef std::map<uint64_t, MappingList::iterator> MappingMap;
     87 
     88   struct MappedRange {
     89     uint64_t real_addr;
     90     uint64_t mapped_addr;
     91     uint64_t size;
     92 
     93     uint64_t id;
     94     uint64_t offset_base;
     95 
     96     // Length of unmapped space after this range.
     97     uint64_t unmapped_space_after;
     98 
     99     // Determines if this range intersects another range in real space.
    100     inline bool Intersects(const MappedRange& range) const {
    101       return (real_addr <= range.real_addr + range.size - 1) &&
    102              (real_addr + size - 1 >= range.real_addr);
    103     }
    104 
    105     // Determines if this range fully covers another range in real space.
    106     inline bool Covers(const MappedRange& range) const {
    107       return (real_addr <= range.real_addr) &&
    108              (real_addr + size - 1 >= range.real_addr + range.size - 1);
    109     }
    110 
    111     // Determines if this range fully contains another range in real space.
    112     // This is different from Covers() in that the boundaries cannot overlap.
    113     inline bool Contains(const MappedRange& range) const {
    114       return (real_addr < range.real_addr) &&
    115              (real_addr + size - 1 > range.real_addr + range.size - 1);
    116     }
    117 
    118     // Determines if this range contains the given address |addr|.
    119     inline bool ContainsAddress(uint64_t addr) const {
    120       return (addr >= real_addr && addr <= real_addr + size - 1);
    121     }
    122   };
    123 
    124   // Returns an iterator to a MappedRange in |mappings_| that contains
    125   // |real_addr|. Returns |mappings_.end()| if no range contains |real_addr|.
    126   MappingList::const_iterator GetRangeContainingAddress(
    127       uint64_t real_addr) const;
    128 
    129   // Removes an existing address mapping, given by an iterator pointing to an
    130   // element of |mappings_|.
    131   void Unmap(MappingList::iterator mapping_iter);
    132 
    133   // Given an address, and a nonzero, power-of-two |page_alignment_| value,
    134   // returns the offset of the address from the start of the page it is on.
    135   // Equivalent to |addr % page_alignment_|. Should not be called if
    136   // |page_alignment_| is zero.
    137   uint64_t GetAlignedOffset(uint64_t addr) const {
    138     return addr & (page_alignment_ - 1);
    139   }
    140 
    141   // Container for all the existing mappings.
    142   MappingList mappings_;
    143 
    144   // Maps real addresses to iterators pointing to entries within |mappings_|.
    145   // Must maintain a 1:1 entry correspondence with |mappings_|.
    146   MappingMap real_addr_to_mapped_range_;
    147 
    148   // If set to nonzero, use this as a mapping page boundary. If a mapping does
    149   // not begin at a multiple of this value, the remapped address should be given
    150   // an offset that is the remainder.
    151   //
    152   // e.g. if alignment=0x1000 and a mapping starts at 0x520100, then the
    153   // remapping should treat the mapping as starting at 0x520000, but addresses
    154   // are only valid starting at 0x520100.
    155   uint64_t page_alignment_;
    156 };
    157 
    158 }  // namespace quipper
    159 
    160 #endif  // CHROMIUMOS_WIDE_PROFILING_ADDRESS_MAPPER_H_
    161