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_LIBARTBASE_BASE_MEM_MAP_H_
18 #define ART_LIBARTBASE_BASE_MEM_MAP_H_
19
20 #include <stddef.h>
21 #include <sys/types.h>
22
23 #include <map>
24 #include <mutex>
25 #include <string>
26
27 #include "android-base/thread_annotations.h"
28 #include "macros.h"
29
30 namespace art {
31
32 #if defined(__LP64__) && !defined(__Fuchsia__) && (defined(__aarch64__) || defined(__APPLE__))
33 #define USE_ART_LOW_4G_ALLOCATOR 1
34 #else
35 #if defined(__LP64__) && !defined(__Fuchsia__) && !defined(__x86_64__)
36 #error "Unrecognized 64-bit architecture."
37 #endif
38 #define USE_ART_LOW_4G_ALLOCATOR 0
39 #endif
40
41 #ifdef __linux__
42 static constexpr bool kMadviseZeroes = true;
43 #define HAVE_MREMAP_SYSCALL true
44 #else
45 static constexpr bool kMadviseZeroes = false;
46 // We cannot ever perform MemMap::ReplaceWith on non-linux hosts since the syscall is not
47 // present.
48 #define HAVE_MREMAP_SYSCALL false
49 #endif
50
51 // Used to keep track of mmap segments.
52 //
53 // On 64b systems not supporting MAP_32BIT, the implementation of MemMap will do a linear scan
54 // for free pages. For security, the start of this scan should be randomized. This requires a
55 // dynamic initializer.
56 // For this to work, it is paramount that there are no other static initializers that access MemMap.
57 // Otherwise, calls might see uninitialized values.
58 class MemMap {
59 public:
60 static constexpr bool kCanReplaceMapping = HAVE_MREMAP_SYSCALL;
61
62 // Creates an invalid mapping.
MemMap()63 MemMap() {}
64
65 // Creates an invalid mapping. Used when we want to be more explicit than MemMap().
Invalid()66 static MemMap Invalid() {
67 return MemMap();
68 }
69
70 MemMap(MemMap&& other) noexcept REQUIRES(!MemMap::mem_maps_lock_);
71 MemMap& operator=(MemMap&& other) noexcept REQUIRES(!MemMap::mem_maps_lock_) {
72 Reset();
73 swap(other);
74 return *this;
75 }
76
77 // Releases the memory mapping.
78 ~MemMap() REQUIRES(!MemMap::mem_maps_lock_);
79
80 // Swap two MemMaps.
81 void swap(MemMap& other);
82
Reset()83 void Reset() {
84 if (IsValid()) {
85 DoReset();
86 }
87 }
88
IsValid()89 bool IsValid() const {
90 return base_size_ != 0u;
91 }
92
93 // Replace the data in this memmmap with the data in the memmap pointed to by source. The caller
94 // relinquishes ownership of the source mmap.
95 //
96 // For the call to be successful:
97 // * The range [dest->Begin, dest->Begin() + source->Size()] must not overlap with
98 // [source->Begin(), source->End()].
99 // * Neither source nor dest may be 'reused' mappings (they must own all the pages associated
100 // with them.
101 // * kCanReplaceMapping must be true.
102 // * Neither source nor dest may use manual redzones.
103 // * Both source and dest must have the same offset from the nearest page boundary.
104 // * mremap must succeed when called on the mappings.
105 //
106 // If this call succeeds it will return true and:
107 // * Invalidate *source
108 // * The protection of this will remain the same.
109 // * The size of this will be the size of the source
110 // * The data in this will be the data from source.
111 //
112 // If this call fails it will return false and make no changes to *source or this. The ownership
113 // of the source mmap is returned to the caller.
114 bool ReplaceWith(/*in-out*/MemMap* source, /*out*/std::string* error);
115
116 // Set a debug friendly name for a map. It will be prefixed with "dalvik-".
117 static void SetDebugName(void* map_ptr, const char* name, size_t size);
118
119 // Request an anonymous region of length 'byte_count' and a requested base address.
120 // Use null as the requested base address if you don't care.
121 //
122 // `reuse` allows re-mapping an address range from an existing mapping which retains the
123 // ownership of the memory. Alternatively, `reservation` allows re-mapping the start of an
124 // existing reservation mapping, transferring the ownership of the memory to the new MemMap.
125 //
126 // The word "anonymous" in this context means "not backed by a file". The supplied
127 // 'name' will be used -- on systems that support it -- to give the mapping
128 // a name.
129 //
130 // On success, returns returns a valid MemMap. On failure, returns an invalid MemMap.
131 static MemMap MapAnonymous(const char* name,
132 uint8_t* addr,
133 size_t byte_count,
134 int prot,
135 bool low_4gb,
136 bool reuse,
137 /*inout*/MemMap* reservation,
138 /*out*/std::string* error_msg,
139 bool use_debug_name = true);
MapAnonymous(const char * name,size_t byte_count,int prot,bool low_4gb,std::string * error_msg)140 static MemMap MapAnonymous(const char* name,
141 size_t byte_count,
142 int prot,
143 bool low_4gb,
144 /*out*/std::string* error_msg) {
145 return MapAnonymous(name,
146 /*addr=*/ nullptr,
147 byte_count,
148 prot,
149 low_4gb,
150 /*reuse=*/ false,
151 /*reservation=*/ nullptr,
152 error_msg);
153 }
MapAnonymous(const char * name,size_t byte_count,int prot,bool low_4gb,MemMap * reservation,std::string * error_msg)154 static MemMap MapAnonymous(const char* name,
155 size_t byte_count,
156 int prot,
157 bool low_4gb,
158 MemMap* reservation,
159 /*out*/std::string* error_msg) {
160 return MapAnonymous(name,
161 /*addr=*/ (reservation != nullptr) ? reservation->Begin() : nullptr,
162 byte_count,
163 prot,
164 low_4gb,
165 /*reuse=*/ false,
166 reservation,
167 error_msg);
168 }
169
170 // Create placeholder for a region allocated by direct call to mmap.
171 // This is useful when we do not have control over the code calling mmap,
172 // but when we still want to keep track of it in the list.
173 // The region is not considered to be owned and will not be unmmaped.
174 static MemMap MapDummy(const char* name, uint8_t* addr, size_t byte_count);
175
176 // Map part of a file, taking care of non-page aligned offsets. The
177 // "start" offset is absolute, not relative.
178 //
179 // On success, returns returns a valid MemMap. On failure, returns an invalid MemMap.
MapFile(size_t byte_count,int prot,int flags,int fd,off_t start,bool low_4gb,const char * filename,std::string * error_msg)180 static MemMap MapFile(size_t byte_count,
181 int prot,
182 int flags,
183 int fd,
184 off_t start,
185 bool low_4gb,
186 const char* filename,
187 std::string* error_msg) {
188 return MapFileAtAddress(nullptr,
189 byte_count,
190 prot,
191 flags,
192 fd,
193 start,
194 /*low_4gb=*/ low_4gb,
195 filename,
196 /*reuse=*/ false,
197 /*reservation=*/ nullptr,
198 error_msg);
199 }
200
201 // Map part of a file, taking care of non-page aligned offsets. The "start" offset is absolute,
202 // not relative. This version allows requesting a specific address for the base of the mapping.
203 //
204 // `reuse` allows re-mapping an address range from an existing mapping which retains the
205 // ownership of the memory. Alternatively, `reservation` allows re-mapping the start of an
206 // existing reservation mapping, transferring the ownership of the memory to the new MemMap.
207 //
208 // If error_msg is null then we do not print /proc/maps to the log if MapFileAtAddress fails.
209 // This helps improve performance of the fail case since reading and printing /proc/maps takes
210 // several milliseconds in the worst case.
211 //
212 // On success, returns returns a valid MemMap. On failure, returns an invalid MemMap.
213 static MemMap MapFileAtAddress(uint8_t* addr,
214 size_t byte_count,
215 int prot,
216 int flags,
217 int fd,
218 off_t start,
219 bool low_4gb,
220 const char* filename,
221 bool reuse,
222 /*inout*/MemMap* reservation,
223 /*out*/std::string* error_msg);
224
GetName()225 const std::string& GetName() const {
226 return name_;
227 }
228
229 bool Sync();
230
231 bool Protect(int prot);
232
233 void MadviseDontNeedAndZero();
234 int MadviseDontFork();
235
GetProtect()236 int GetProtect() const {
237 return prot_;
238 }
239
Begin()240 uint8_t* Begin() const {
241 return begin_;
242 }
243
Size()244 size_t Size() const {
245 return size_;
246 }
247
248 // Resize the mem-map by unmapping pages at the end. Currently only supports shrinking.
249 void SetSize(size_t new_size);
250
End()251 uint8_t* End() const {
252 return Begin() + Size();
253 }
254
BaseBegin()255 void* BaseBegin() const {
256 return base_begin_;
257 }
258
BaseSize()259 size_t BaseSize() const {
260 return base_size_;
261 }
262
BaseEnd()263 void* BaseEnd() const {
264 return reinterpret_cast<uint8_t*>(BaseBegin()) + BaseSize();
265 }
266
HasAddress(const void * addr)267 bool HasAddress(const void* addr) const {
268 return Begin() <= addr && addr < End();
269 }
270
271 // Unmap the pages at end and remap them to create another memory map.
272 MemMap RemapAtEnd(uint8_t* new_end,
273 const char* tail_name,
274 int tail_prot,
275 std::string* error_msg,
276 bool use_debug_name = true);
277
278 // Unmap the pages of a file at end and remap them to create another memory map.
279 MemMap RemapAtEnd(uint8_t* new_end,
280 const char* tail_name,
281 int tail_prot,
282 int tail_flags,
283 int fd,
284 off_t offset,
285 std::string* error_msg,
286 bool use_debug_name = true);
287
288 // Take ownership of pages at the beginning of the mapping. The mapping must be an
289 // anonymous reservation mapping, owning entire pages. The `byte_count` must not
290 // exceed the size of this reservation.
291 //
292 // Returns a mapping owning `byte_count` bytes rounded up to entire pages
293 // with size set to the passed `byte_count`.
294 MemMap TakeReservedMemory(size_t byte_count);
295
296 static bool CheckNoGaps(MemMap& begin_map, MemMap& end_map)
297 REQUIRES(!MemMap::mem_maps_lock_);
298 static void DumpMaps(std::ostream& os, bool terse = false)
299 REQUIRES(!MemMap::mem_maps_lock_);
300
301 // Init and Shutdown are NOT thread safe.
302 // Both may be called multiple times and MemMap objects may be created any
303 // time after the first call to Init and before the first call to Shutodwn.
304 static void Init() REQUIRES(!MemMap::mem_maps_lock_);
305 static void Shutdown() REQUIRES(!MemMap::mem_maps_lock_);
306
307 // If the map is PROT_READ, try to read each page of the map to check it is in fact readable (not
308 // faulting). This is used to diagnose a bug b/19894268 where mprotect doesn't seem to be working
309 // intermittently.
310 void TryReadable();
311
312 // Align the map by unmapping the unaligned parts at the lower and the higher ends.
313 void AlignBy(size_t size);
314
315 // For annotation reasons.
GetMemMapsLock()316 static std::mutex* GetMemMapsLock() RETURN_CAPABILITY(mem_maps_lock_) {
317 return nullptr;
318 }
319
320 // Reset in a forked process the MemMap whose memory has been madvised MADV_DONTFORK
321 // in the parent process.
322 void ResetInForkedProcess();
323
324 private:
325 MemMap(const std::string& name,
326 uint8_t* begin,
327 size_t size,
328 void* base_begin,
329 size_t base_size,
330 int prot,
331 bool reuse,
332 size_t redzone_size = 0) REQUIRES(!MemMap::mem_maps_lock_);
333
334 void DoReset();
335 void Invalidate();
336 void SwapMembers(MemMap& other);
337
338 static void DumpMapsLocked(std::ostream& os, bool terse)
339 REQUIRES(MemMap::mem_maps_lock_);
340 static bool HasMemMap(MemMap& map)
341 REQUIRES(MemMap::mem_maps_lock_);
342 static MemMap* GetLargestMemMapAt(void* address)
343 REQUIRES(MemMap::mem_maps_lock_);
344 static bool ContainedWithinExistingMap(uint8_t* ptr, size_t size, std::string* error_msg)
345 REQUIRES(!MemMap::mem_maps_lock_);
346
347 // Internal version of mmap that supports low 4gb emulation.
348 static void* MapInternal(void* addr,
349 size_t length,
350 int prot,
351 int flags,
352 int fd,
353 off_t offset,
354 bool low_4gb)
355 REQUIRES(!MemMap::mem_maps_lock_);
356 static void* MapInternalArtLow4GBAllocator(size_t length,
357 int prot,
358 int flags,
359 int fd,
360 off_t offset)
361 REQUIRES(!MemMap::mem_maps_lock_);
362
363 // Release memory owned by a reservation mapping.
364 void ReleaseReservedMemory(size_t byte_count);
365
366 // member function to access real_munmap
367 static bool CheckMapRequest(uint8_t* expected_ptr,
368 void* actual_ptr,
369 size_t byte_count,
370 std::string* error_msg);
371
372 static bool CheckReservation(uint8_t* expected_ptr,
373 size_t byte_count,
374 const char* name,
375 const MemMap& reservation,
376 /*out*/std::string* error_msg);
377
378 std::string name_;
379 uint8_t* begin_ = nullptr; // Start of data. May be changed by AlignBy.
380 size_t size_ = 0u; // Length of data.
381
382 void* base_begin_ = nullptr; // Page-aligned base address. May be changed by AlignBy.
383 size_t base_size_ = 0u; // Length of mapping. May be changed by RemapAtEnd (ie Zygote).
384 int prot_ = 0; // Protection of the map.
385
386 // When reuse_ is true, this is just a view of an existing mapping
387 // and we do not take ownership and are not responsible for
388 // unmapping.
389 bool reuse_ = false;
390
391 // When already_unmapped_ is true the destructor will not call munmap.
392 bool already_unmapped_ = false;
393
394 size_t redzone_size_ = 0u;
395
396 #if USE_ART_LOW_4G_ALLOCATOR
397 static uintptr_t next_mem_pos_; // Next memory location to check for low_4g extent.
398
399 static void* TryMemMapLow4GB(void* ptr,
400 size_t page_aligned_byte_count,
401 int prot,
402 int flags,
403 int fd,
404 off_t offset);
405 #endif
406
407 static void TargetMMapInit();
408 static void* TargetMMap(void* start, size_t len, int prot, int flags, int fd, off_t fd_off);
409 static int TargetMUnmap(void* start, size_t len);
410
411 static std::mutex* mem_maps_lock_;
412
413 friend class MemMapTest; // To allow access to base_begin_ and base_size_.
414 };
415
swap(MemMap & lhs,MemMap & rhs)416 inline void swap(MemMap& lhs, MemMap& rhs) {
417 lhs.swap(rhs);
418 }
419
420 std::ostream& operator<<(std::ostream& os, const MemMap& mem_map);
421
422 // Zero and release pages if possible, no requirements on alignments.
423 void ZeroAndReleasePages(void* address, size_t length);
424
425 } // namespace art
426
427 #endif // ART_LIBARTBASE_BASE_MEM_MAP_H_
428