mem_map.h revision c5f17732d8144491c642776b6b48c85dfadf4b52
1/* 2 * Copyright (C) 2008 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 ART_RUNTIME_MEM_MAP_H_ 18#define ART_RUNTIME_MEM_MAP_H_ 19 20#include "base/mutex.h" 21 22#include <string> 23#include <map> 24 25#include <stddef.h> 26#include <sys/mman.h> // For the PROT_* and MAP_* constants. 27#include <sys/types.h> 28 29#include "globals.h" 30 31namespace art { 32 33#ifdef __linux__ 34static constexpr bool kMadviseZeroes = true; 35#else 36static constexpr bool kMadviseZeroes = false; 37#endif 38 39// Used to keep track of mmap segments. 40// 41// On 64b systems not supporting MAP_32BIT, the implementation of MemMap will do a linear scan 42// for free pages. For security, the start of this scan should be randomized. This requires a 43// dynamic initializer. 44// For this to work, it is paramount that there are no other static initializers that access MemMap. 45// Otherwise, calls might see uninitialized values. 46class MemMap { 47 public: 48 // Request an anonymous region of length 'byte_count' and a requested base address. 49 // Use NULL as the requested base address if you don't care. 50 // 51 // The word "anonymous" in this context means "not backed by a file". The supplied 52 // 'ashmem_name' will be used -- on systems that support it -- to give the mapping 53 // a name. 54 // 55 // On success, returns returns a MemMap instance. On failure, returns a NULL; 56 static MemMap* MapAnonymous(const char* ashmem_name, byte* addr, size_t byte_count, int prot, 57 bool low_4gb, std::string* error_msg); 58 59 // Map part of a file, taking care of non-page aligned offsets. The 60 // "start" offset is absolute, not relative. 61 // 62 // On success, returns returns a MemMap instance. On failure, returns a NULL; 63 static MemMap* MapFile(size_t byte_count, int prot, int flags, int fd, off_t start, 64 const char* filename, std::string* error_msg) { 65 return MapFileAtAddress(NULL, byte_count, prot, flags, fd, start, false, filename, error_msg); 66 } 67 68 // Map part of a file, taking care of non-page aligned offsets. The 69 // "start" offset is absolute, not relative. This version allows 70 // requesting a specific address for the base of the mapping. 71 // 72 // On success, returns returns a MemMap instance. On failure, returns a NULL; 73 static MemMap* MapFileAtAddress(byte* addr, size_t byte_count, int prot, int flags, int fd, 74 off_t start, bool reuse, const char* filename, 75 std::string* error_msg); 76 77 // Releases the memory mapping 78 ~MemMap() LOCKS_EXCLUDED(Locks::mem_maps_lock_); 79 80 const std::string& GetName() const { 81 return name_; 82 } 83 84 bool Protect(int prot); 85 86 void MadviseDontNeedAndZero(); 87 88 int GetProtect() const { 89 return prot_; 90 } 91 92 byte* Begin() const { 93 return begin_; 94 } 95 96 size_t Size() const { 97 return size_; 98 } 99 100 byte* End() const { 101 return Begin() + Size(); 102 } 103 104 void* BaseBegin() const { 105 return base_begin_; 106 } 107 108 size_t BaseSize() const { 109 return base_size_; 110 } 111 112 void* BaseEnd() const { 113 return reinterpret_cast<byte*>(BaseBegin()) + BaseSize(); 114 } 115 116 bool HasAddress(const void* addr) const { 117 return Begin() <= addr && addr < End(); 118 } 119 120 // Unmap the pages at end and remap them to create another memory map. 121 MemMap* RemapAtEnd(byte* new_end, const char* tail_name, int tail_prot, 122 std::string* error_msg); 123 124 static bool CheckNoGaps(MemMap* begin_map, MemMap* end_map) 125 LOCKS_EXCLUDED(Locks::mem_maps_lock_); 126 static void DumpMaps(std::ostream& os) 127 LOCKS_EXCLUDED(Locks::mem_maps_lock_); 128 129 private: 130 MemMap(const std::string& name, byte* begin, size_t size, void* base_begin, size_t base_size, 131 int prot) LOCKS_EXCLUDED(Locks::mem_maps_lock_); 132 133 static void DumpMaps(std::ostream& os, const std::multimap<void*, MemMap*>& mem_maps) 134 LOCKS_EXCLUDED(Locks::mem_maps_lock_); 135 static void DumpMapsLocked(std::ostream& os, const std::multimap<void*, MemMap*>& mem_maps) 136 EXCLUSIVE_LOCKS_REQUIRED(Locks::mem_maps_lock_); 137 static bool HasMemMap(MemMap* map) 138 EXCLUSIVE_LOCKS_REQUIRED(Locks::mem_maps_lock_); 139 static MemMap* GetLargestMemMapAt(void* address) 140 EXCLUSIVE_LOCKS_REQUIRED(Locks::mem_maps_lock_); 141 142 std::string name_; 143 byte* const begin_; // Start of data. 144 size_t size_; // Length of data. 145 146 void* const base_begin_; // Page-aligned base address. 147 size_t base_size_; // Length of mapping. May be changed by RemapAtEnd (ie Zygote). 148 int prot_; // Protection of the map. 149 150#if defined(__LP64__) && !defined(__x86_64__) 151 static uintptr_t next_mem_pos_; // next memory location to check for low_4g extent 152#endif 153 154 // All the non-empty MemMaps. Use a multimap as we do a reserve-and-divide (eg ElfMap::Load()). 155 static std::multimap<void*, MemMap*> maps_ GUARDED_BY(Locks::mem_maps_lock_); 156 157 friend class MemMapTest; // To allow access to base_begin_ and base_size_. 158}; 159std::ostream& operator<<(std::ostream& os, const MemMap& mem_map); 160 161} // namespace art 162 163#endif // ART_RUNTIME_MEM_MAP_H_ 164