mem_map.cc revision 6e88ef6b604a7a945a466784580c42e6554c1289
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#include "mem_map.h" 18#include "thread-inl.h" 19 20#include <inttypes.h> 21#include <backtrace/BacktraceMap.h> 22#include <memory> 23 24// See CreateStartPos below. 25#ifdef __BIONIC__ 26#include <sys/auxv.h> 27#endif 28 29#include "base/stringprintf.h" 30#include "ScopedFd.h" 31#include "utils.h" 32 33#define USE_ASHMEM 1 34 35#ifdef USE_ASHMEM 36#include <cutils/ashmem.h> 37#ifndef ANDROID_OS 38#include <sys/resource.h> 39#endif 40#endif 41 42#ifndef MAP_ANONYMOUS 43#define MAP_ANONYMOUS MAP_ANON 44#endif 45 46namespace art { 47 48static std::ostream& operator<<( 49 std::ostream& os, 50 std::pair<BacktraceMap::const_iterator, BacktraceMap::const_iterator> iters) { 51 for (BacktraceMap::const_iterator it = iters.first; it != iters.second; ++it) { 52 os << StringPrintf("0x%08x-0x%08x %c%c%c %s\n", 53 static_cast<uint32_t>(it->start), 54 static_cast<uint32_t>(it->end), 55 (it->flags & PROT_READ) ? 'r' : '-', 56 (it->flags & PROT_WRITE) ? 'w' : '-', 57 (it->flags & PROT_EXEC) ? 'x' : '-', it->name.c_str()); 58 } 59 return os; 60} 61 62std::ostream& operator<<(std::ostream& os, const MemMap::Maps& mem_maps) { 63 os << "MemMap:" << std::endl; 64 for (auto it = mem_maps.begin(); it != mem_maps.end(); ++it) { 65 void* base = it->first; 66 MemMap* map = it->second; 67 CHECK_EQ(base, map->BaseBegin()); 68 os << *map << std::endl; 69 } 70 return os; 71} 72 73MemMap::Maps* MemMap::maps_ = nullptr; 74 75#if USE_ART_LOW_4G_ALLOCATOR 76// Handling mem_map in 32b address range for 64b architectures that do not support MAP_32BIT. 77 78// The regular start of memory allocations. The first 64KB is protected by SELinux. 79static constexpr uintptr_t LOW_MEM_START = 64 * KB; 80 81// Generate random starting position. 82// To not interfere with image position, take the image's address and only place it below. Current 83// formula (sketch): 84// 85// ART_BASE_ADDR = 0001XXXXXXXXXXXXXXX 86// ---------------------------------------- 87// = 0000111111111111111 88// & ~(kPageSize - 1) =~0000000000000001111 89// ---------------------------------------- 90// mask = 0000111111111110000 91// & random data = YYYYYYYYYYYYYYYYYYY 92// ----------------------------------- 93// tmp = 0000YYYYYYYYYYY0000 94// + LOW_MEM_START = 0000000000001000000 95// -------------------------------------- 96// start 97// 98// getauxval as an entropy source is exposed in Bionic, but not in glibc before 2.16. When we 99// do not have Bionic, simply start with LOW_MEM_START. 100 101// Function is standalone so it can be tested somewhat in mem_map_test.cc. 102#ifdef __BIONIC__ 103uintptr_t CreateStartPos(uint64_t input) { 104 CHECK_NE(0, ART_BASE_ADDRESS); 105 106 // Start with all bits below highest bit in ART_BASE_ADDRESS. 107 constexpr size_t leading_zeros = CLZ(static_cast<uint32_t>(ART_BASE_ADDRESS)); 108 constexpr uintptr_t mask_ones = (1 << (31 - leading_zeros)) - 1; 109 110 // Lowest (usually 12) bits are not used, as aligned by page size. 111 constexpr uintptr_t mask = mask_ones & ~(kPageSize - 1); 112 113 // Mask input data. 114 return (input & mask) + LOW_MEM_START; 115} 116#endif 117 118static uintptr_t GenerateNextMemPos() { 119#ifdef __BIONIC__ 120 uint8_t* random_data = reinterpret_cast<uint8_t*>(getauxval(AT_RANDOM)); 121 // The lower 8B are taken for the stack guard. Use the upper 8B (with mask). 122 return CreateStartPos(*reinterpret_cast<uintptr_t*>(random_data + 8)); 123#else 124 // No auxv on host, see above. 125 return LOW_MEM_START; 126#endif 127} 128 129// Initialize linear scan to random position. 130uintptr_t MemMap::next_mem_pos_ = GenerateNextMemPos(); 131#endif 132 133// Return true if the address range is contained in a single /proc/self/map entry. 134static bool ContainedWithinExistingMap(uintptr_t begin, 135 uintptr_t end, 136 std::string* error_msg) { 137 std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid(), true)); 138 if (map.get() == nullptr) { 139 *error_msg = StringPrintf("Failed to build process map"); 140 return false; 141 } 142 for (BacktraceMap::const_iterator it = map->begin(); it != map->end(); ++it) { 143 if ((begin >= it->start && begin < it->end) // start of new within old 144 && (end > it->start && end <= it->end)) { // end of new within old 145 return true; 146 } 147 } 148 std::string maps; 149 ReadFileToString("/proc/self/maps", &maps); 150 *error_msg = StringPrintf("Requested region 0x%08" PRIxPTR "-0x%08" PRIxPTR " does not overlap " 151 "any existing map:\n%s\n", 152 begin, end, maps.c_str()); 153 return false; 154} 155 156// Return true if the address range does not conflict with any /proc/self/maps entry. 157static bool CheckNonOverlapping(uintptr_t begin, 158 uintptr_t end, 159 std::string* error_msg) { 160 std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid(), true)); 161 if (map.get() == nullptr) { 162 *error_msg = StringPrintf("Failed to build process map"); 163 return false; 164 } 165 for (BacktraceMap::const_iterator it = map->begin(); it != map->end(); ++it) { 166 if ((begin >= it->start && begin < it->end) // start of new within old 167 || (end > it->start && end < it->end) // end of new within old 168 || (begin <= it->start && end > it->end)) { // start/end of new includes all of old 169 std::ostringstream map_info; 170 map_info << std::make_pair(it, map->end()); 171 *error_msg = StringPrintf("Requested region 0x%08" PRIxPTR "-0x%08" PRIxPTR " overlaps with " 172 "existing map 0x%08" PRIxPTR "-0x%08" PRIxPTR " (%s)\n%s", 173 begin, end, 174 static_cast<uintptr_t>(it->start), static_cast<uintptr_t>(it->end), 175 it->name.c_str(), 176 map_info.str().c_str()); 177 return false; 178 } 179 } 180 return true; 181} 182 183// CheckMapRequest to validate a non-MAP_FAILED mmap result based on 184// the expected value, calling munmap if validation fails, giving the 185// reason in error_msg. 186// 187// If the expected_ptr is nullptr, nothing is checked beyond the fact 188// that the actual_ptr is not MAP_FAILED. However, if expected_ptr is 189// non-null, we check that pointer is the actual_ptr == expected_ptr, 190// and if not, report in error_msg what the conflict mapping was if 191// found, or a generic error in other cases. 192static bool CheckMapRequest(uint8_t* expected_ptr, void* actual_ptr, size_t byte_count, 193 std::string* error_msg) { 194 // Handled first by caller for more specific error messages. 195 CHECK(actual_ptr != MAP_FAILED); 196 197 if (expected_ptr == nullptr) { 198 return true; 199 } 200 201 uintptr_t actual = reinterpret_cast<uintptr_t>(actual_ptr); 202 uintptr_t expected = reinterpret_cast<uintptr_t>(expected_ptr); 203 uintptr_t limit = expected + byte_count; 204 205 if (expected_ptr == actual_ptr) { 206 return true; 207 } 208 209 // We asked for an address but didn't get what we wanted, all paths below here should fail. 210 int result = munmap(actual_ptr, byte_count); 211 if (result == -1) { 212 PLOG(WARNING) << StringPrintf("munmap(%p, %zd) failed", actual_ptr, byte_count); 213 } 214 215 // We call this here so that we can try and generate a full error 216 // message with the overlapping mapping. There's no guarantee that 217 // that there will be an overlap though, since 218 // - The kernel is not *required* to honour expected_ptr unless MAP_FIXED is 219 // true, even if there is no overlap 220 // - There might have been an overlap at the point of mmap, but the 221 // overlapping region has since been unmapped. 222 std::string error_detail; 223 CheckNonOverlapping(expected, limit, &error_detail); 224 225 std::ostringstream os; 226 os << StringPrintf("Failed to mmap at expected address, mapped at " 227 "0x%08" PRIxPTR " instead of 0x%08" PRIxPTR, 228 actual, expected); 229 if (!error_detail.empty()) { 230 os << " : " << error_detail; 231 } 232 233 *error_msg = os.str(); 234 return false; 235} 236 237MemMap* MemMap::MapAnonymous(const char* name, uint8_t* expected_ptr, size_t byte_count, int prot, 238 bool low_4gb, std::string* error_msg) { 239 if (byte_count == 0) { 240 return new MemMap(name, nullptr, 0, nullptr, 0, prot, false); 241 } 242 size_t page_aligned_byte_count = RoundUp(byte_count, kPageSize); 243 244 int flags = MAP_PRIVATE | MAP_ANONYMOUS; 245 ScopedFd fd(-1); 246 247#ifdef USE_ASHMEM 248#ifdef HAVE_ANDROID_OS 249 const bool use_ashmem = true; 250#else 251 // When not on Android ashmem is faked using files in /tmp. Ensure that such files won't 252 // fail due to ulimit restrictions. If they will then use a regular mmap. 253 struct rlimit rlimit_fsize; 254 CHECK_EQ(getrlimit(RLIMIT_FSIZE, &rlimit_fsize), 0); 255 const bool use_ashmem = (rlimit_fsize.rlim_cur == RLIM_INFINITY) || 256 (page_aligned_byte_count < rlimit_fsize.rlim_cur); 257#endif 258 if (use_ashmem) { 259 // android_os_Debug.cpp read_mapinfo assumes all ashmem regions associated with the VM are 260 // prefixed "dalvik-". 261 std::string debug_friendly_name("dalvik-"); 262 debug_friendly_name += name; 263 fd.reset(ashmem_create_region(debug_friendly_name.c_str(), page_aligned_byte_count)); 264 if (fd.get() == -1) { 265 *error_msg = StringPrintf("ashmem_create_region failed for '%s': %s", name, strerror(errno)); 266 return nullptr; 267 } 268 flags = MAP_PRIVATE; 269 } 270#endif 271 272 // We need to store and potentially set an error number for pretty printing of errors 273 int saved_errno = 0; 274 275#ifdef __LP64__ 276 // When requesting low_4g memory and having an expectation, the requested range should fit into 277 // 4GB. 278 if (low_4gb && ( 279 // Start out of bounds. 280 (reinterpret_cast<uintptr_t>(expected_ptr) >> 32) != 0 || 281 // End out of bounds. For simplicity, this will fail for the last page of memory. 282 (reinterpret_cast<uintptr_t>(expected_ptr + page_aligned_byte_count) >> 32) != 0)) { 283 *error_msg = StringPrintf("The requested address space (%p, %p) cannot fit in low_4gb", 284 expected_ptr, expected_ptr + page_aligned_byte_count); 285 return nullptr; 286 } 287#endif 288 289 // TODO: 290 // A page allocator would be a useful abstraction here, as 291 // 1) It is doubtful that MAP_32BIT on x86_64 is doing the right job for us 292 // 2) The linear scheme, even with simple saving of the last known position, is very crude 293#if USE_ART_LOW_4G_ALLOCATOR 294 // MAP_32BIT only available on x86_64. 295 void* actual = MAP_FAILED; 296 if (low_4gb && expected_ptr == nullptr) { 297 bool first_run = true; 298 299 for (uintptr_t ptr = next_mem_pos_; ptr < 4 * GB; ptr += kPageSize) { 300 if (4U * GB - ptr < page_aligned_byte_count) { 301 // Not enough memory until 4GB. 302 if (first_run) { 303 // Try another time from the bottom; 304 ptr = LOW_MEM_START - kPageSize; 305 first_run = false; 306 continue; 307 } else { 308 // Second try failed. 309 break; 310 } 311 } 312 313 uintptr_t tail_ptr; 314 315 // Check pages are free. 316 bool safe = true; 317 for (tail_ptr = ptr; tail_ptr < ptr + page_aligned_byte_count; tail_ptr += kPageSize) { 318 if (msync(reinterpret_cast<void*>(tail_ptr), kPageSize, 0) == 0) { 319 safe = false; 320 break; 321 } else { 322 DCHECK_EQ(errno, ENOMEM); 323 } 324 } 325 326 next_mem_pos_ = tail_ptr; // update early, as we break out when we found and mapped a region 327 328 if (safe == true) { 329 actual = mmap(reinterpret_cast<void*>(ptr), page_aligned_byte_count, prot, flags, fd.get(), 330 0); 331 if (actual != MAP_FAILED) { 332 // Since we didn't use MAP_FIXED the kernel may have mapped it somewhere not in the low 333 // 4GB. If this is the case, unmap and retry. 334 if (reinterpret_cast<uintptr_t>(actual) + page_aligned_byte_count < 4 * GB) { 335 break; 336 } else { 337 munmap(actual, page_aligned_byte_count); 338 actual = MAP_FAILED; 339 } 340 } 341 } else { 342 // Skip over last page. 343 ptr = tail_ptr; 344 } 345 } 346 347 if (actual == MAP_FAILED) { 348 LOG(ERROR) << "Could not find contiguous low-memory space."; 349 saved_errno = ENOMEM; 350 } 351 } else { 352 actual = mmap(expected_ptr, page_aligned_byte_count, prot, flags, fd.get(), 0); 353 saved_errno = errno; 354 } 355 356#else 357#if defined(__LP64__) 358 if (low_4gb && expected_ptr == nullptr) { 359 flags |= MAP_32BIT; 360 } 361#endif 362 363 void* actual = mmap(expected_ptr, page_aligned_byte_count, prot, flags, fd.get(), 0); 364 saved_errno = errno; 365#endif 366 367 if (actual == MAP_FAILED) { 368 std::string maps; 369 ReadFileToString("/proc/self/maps", &maps); 370 371 *error_msg = StringPrintf("Failed anonymous mmap(%p, %zd, 0x%x, 0x%x, %d, 0): %s\n%s", 372 expected_ptr, page_aligned_byte_count, prot, flags, fd.get(), 373 strerror(saved_errno), maps.c_str()); 374 return nullptr; 375 } 376 std::ostringstream check_map_request_error_msg; 377 if (!CheckMapRequest(expected_ptr, actual, page_aligned_byte_count, error_msg)) { 378 return nullptr; 379 } 380 return new MemMap(name, reinterpret_cast<uint8_t*>(actual), byte_count, actual, 381 page_aligned_byte_count, prot, false); 382} 383 384MemMap* MemMap::MapFileAtAddress(uint8_t* expected_ptr, size_t byte_count, int prot, int flags, int fd, 385 off_t start, bool reuse, const char* filename, 386 std::string* error_msg) { 387 CHECK_NE(0, prot); 388 CHECK_NE(0, flags & (MAP_SHARED | MAP_PRIVATE)); 389 uintptr_t expected = reinterpret_cast<uintptr_t>(expected_ptr); 390 uintptr_t limit = expected + byte_count; 391 392 // Note that we do not allow MAP_FIXED unless reuse == true, i.e we 393 // expect his mapping to be contained within an existing map. 394 if (reuse) { 395 // reuse means it is okay that it overlaps an existing page mapping. 396 // Only use this if you actually made the page reservation yourself. 397 CHECK(expected_ptr != nullptr); 398 399 DCHECK(ContainedWithinExistingMap(expected, limit, error_msg)); 400 flags |= MAP_FIXED; 401 } else { 402 CHECK_EQ(0, flags & MAP_FIXED); 403 // Don't bother checking for an overlapping region here. We'll 404 // check this if required after the fact inside CheckMapRequest. 405 } 406 407 if (byte_count == 0) { 408 return new MemMap(filename, nullptr, 0, nullptr, 0, prot, false); 409 } 410 // Adjust 'offset' to be page-aligned as required by mmap. 411 int page_offset = start % kPageSize; 412 off_t page_aligned_offset = start - page_offset; 413 // Adjust 'byte_count' to be page-aligned as we will map this anyway. 414 size_t page_aligned_byte_count = RoundUp(byte_count + page_offset, kPageSize); 415 // The 'expected_ptr' is modified (if specified, ie non-null) to be page aligned to the file but 416 // not necessarily to virtual memory. mmap will page align 'expected' for us. 417 uint8_t* page_aligned_expected = (expected_ptr == nullptr) ? nullptr : (expected_ptr - page_offset); 418 419 uint8_t* actual = reinterpret_cast<uint8_t*>(mmap(page_aligned_expected, 420 page_aligned_byte_count, 421 prot, 422 flags, 423 fd, 424 page_aligned_offset)); 425 if (actual == MAP_FAILED) { 426 auto saved_errno = errno; 427 428 std::string maps; 429 ReadFileToString("/proc/self/maps", &maps); 430 431 *error_msg = StringPrintf("mmap(%p, %zd, 0x%x, 0x%x, %d, %" PRId64 432 ") of file '%s' failed: %s\n%s", 433 page_aligned_expected, page_aligned_byte_count, prot, flags, fd, 434 static_cast<int64_t>(page_aligned_offset), filename, 435 strerror(saved_errno), maps.c_str()); 436 return nullptr; 437 } 438 std::ostringstream check_map_request_error_msg; 439 if (!CheckMapRequest(expected_ptr, actual, page_aligned_byte_count, error_msg)) { 440 return nullptr; 441 } 442 return new MemMap(filename, actual + page_offset, byte_count, actual, page_aligned_byte_count, 443 prot, reuse); 444} 445 446MemMap::~MemMap() { 447 if (base_begin_ == nullptr && base_size_ == 0) { 448 return; 449 } 450 if (!reuse_) { 451 int result = munmap(base_begin_, base_size_); 452 if (result == -1) { 453 PLOG(FATAL) << "munmap failed"; 454 } 455 } 456 457 // Remove it from maps_. 458 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 459 bool found = false; 460 DCHECK(maps_ != nullptr); 461 for (auto it = maps_->lower_bound(base_begin_), end = maps_->end(); 462 it != end && it->first == base_begin_; ++it) { 463 if (it->second == this) { 464 found = true; 465 maps_->erase(it); 466 break; 467 } 468 } 469 CHECK(found) << "MemMap not found"; 470} 471 472MemMap::MemMap(const std::string& name, uint8_t* begin, size_t size, void* base_begin, 473 size_t base_size, int prot, bool reuse) 474 : name_(name), begin_(begin), size_(size), base_begin_(base_begin), base_size_(base_size), 475 prot_(prot), reuse_(reuse) { 476 if (size_ == 0) { 477 CHECK(begin_ == nullptr); 478 CHECK(base_begin_ == nullptr); 479 CHECK_EQ(base_size_, 0U); 480 } else { 481 CHECK(begin_ != nullptr); 482 CHECK(base_begin_ != nullptr); 483 CHECK_NE(base_size_, 0U); 484 485 // Add it to maps_. 486 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 487 DCHECK(maps_ != nullptr); 488 maps_->insert(std::make_pair(base_begin_, this)); 489 } 490} 491 492MemMap* MemMap::RemapAtEnd(uint8_t* new_end, const char* tail_name, int tail_prot, 493 std::string* error_msg) { 494 DCHECK_GE(new_end, Begin()); 495 DCHECK_LE(new_end, End()); 496 DCHECK_LE(begin_ + size_, reinterpret_cast<uint8_t*>(base_begin_) + base_size_); 497 DCHECK(IsAligned<kPageSize>(begin_)); 498 DCHECK(IsAligned<kPageSize>(base_begin_)); 499 DCHECK(IsAligned<kPageSize>(reinterpret_cast<uint8_t*>(base_begin_) + base_size_)); 500 DCHECK(IsAligned<kPageSize>(new_end)); 501 uint8_t* old_end = begin_ + size_; 502 uint8_t* old_base_end = reinterpret_cast<uint8_t*>(base_begin_) + base_size_; 503 uint8_t* new_base_end = new_end; 504 DCHECK_LE(new_base_end, old_base_end); 505 if (new_base_end == old_base_end) { 506 return new MemMap(tail_name, nullptr, 0, nullptr, 0, tail_prot, false); 507 } 508 size_ = new_end - reinterpret_cast<uint8_t*>(begin_); 509 base_size_ = new_base_end - reinterpret_cast<uint8_t*>(base_begin_); 510 DCHECK_LE(begin_ + size_, reinterpret_cast<uint8_t*>(base_begin_) + base_size_); 511 size_t tail_size = old_end - new_end; 512 uint8_t* tail_base_begin = new_base_end; 513 size_t tail_base_size = old_base_end - new_base_end; 514 DCHECK_EQ(tail_base_begin + tail_base_size, old_base_end); 515 DCHECK(IsAligned<kPageSize>(tail_base_size)); 516 517#ifdef USE_ASHMEM 518 // android_os_Debug.cpp read_mapinfo assumes all ashmem regions associated with the VM are 519 // prefixed "dalvik-". 520 std::string debug_friendly_name("dalvik-"); 521 debug_friendly_name += tail_name; 522 ScopedFd fd(ashmem_create_region(debug_friendly_name.c_str(), tail_base_size)); 523 int flags = MAP_PRIVATE | MAP_FIXED; 524 if (fd.get() == -1) { 525 *error_msg = StringPrintf("ashmem_create_region failed for '%s': %s", 526 tail_name, strerror(errno)); 527 return nullptr; 528 } 529#else 530 ScopedFd fd(-1); 531 int flags = MAP_PRIVATE | MAP_ANONYMOUS; 532#endif 533 534 // Unmap/map the tail region. 535 int result = munmap(tail_base_begin, tail_base_size); 536 if (result == -1) { 537 std::string maps; 538 ReadFileToString("/proc/self/maps", &maps); 539 *error_msg = StringPrintf("munmap(%p, %zd) failed for '%s'\n%s", 540 tail_base_begin, tail_base_size, name_.c_str(), 541 maps.c_str()); 542 return nullptr; 543 } 544 // Don't cause memory allocation between the munmap and the mmap 545 // calls. Otherwise, libc (or something else) might take this memory 546 // region. Note this isn't perfect as there's no way to prevent 547 // other threads to try to take this memory region here. 548 uint8_t* actual = reinterpret_cast<uint8_t*>(mmap(tail_base_begin, tail_base_size, tail_prot, 549 flags, fd.get(), 0)); 550 if (actual == MAP_FAILED) { 551 std::string maps; 552 ReadFileToString("/proc/self/maps", &maps); 553 *error_msg = StringPrintf("anonymous mmap(%p, %zd, 0x%x, 0x%x, %d, 0) failed\n%s", 554 tail_base_begin, tail_base_size, tail_prot, flags, fd.get(), 555 maps.c_str()); 556 return nullptr; 557 } 558 return new MemMap(tail_name, actual, tail_size, actual, tail_base_size, tail_prot, false); 559} 560 561void MemMap::MadviseDontNeedAndZero() { 562 if (base_begin_ != nullptr || base_size_ != 0) { 563 if (!kMadviseZeroes) { 564 memset(base_begin_, 0, base_size_); 565 } 566 int result = madvise(base_begin_, base_size_, MADV_DONTNEED); 567 if (result == -1) { 568 PLOG(WARNING) << "madvise failed"; 569 } 570 } 571} 572 573bool MemMap::Protect(int prot) { 574 if (base_begin_ == nullptr && base_size_ == 0) { 575 prot_ = prot; 576 return true; 577 } 578 579 if (mprotect(base_begin_, base_size_, prot) == 0) { 580 prot_ = prot; 581 return true; 582 } 583 584 PLOG(ERROR) << "mprotect(" << reinterpret_cast<void*>(base_begin_) << ", " << base_size_ << ", " 585 << prot << ") failed"; 586 return false; 587} 588 589bool MemMap::CheckNoGaps(MemMap* begin_map, MemMap* end_map) { 590 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 591 CHECK(begin_map != nullptr); 592 CHECK(end_map != nullptr); 593 CHECK(HasMemMap(begin_map)); 594 CHECK(HasMemMap(end_map)); 595 CHECK_LE(begin_map->BaseBegin(), end_map->BaseBegin()); 596 MemMap* map = begin_map; 597 while (map->BaseBegin() != end_map->BaseBegin()) { 598 MemMap* next_map = GetLargestMemMapAt(map->BaseEnd()); 599 if (next_map == nullptr) { 600 // Found a gap. 601 return false; 602 } 603 map = next_map; 604 } 605 return true; 606} 607 608void MemMap::DumpMaps(std::ostream& os) { 609 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 610 DumpMapsLocked(os); 611} 612 613void MemMap::DumpMapsLocked(std::ostream& os) { 614 os << maps_; 615} 616 617bool MemMap::HasMemMap(MemMap* map) { 618 void* base_begin = map->BaseBegin(); 619 for (auto it = maps_->lower_bound(base_begin), end = maps_->end(); 620 it != end && it->first == base_begin; ++it) { 621 if (it->second == map) { 622 return true; 623 } 624 } 625 return false; 626} 627 628MemMap* MemMap::GetLargestMemMapAt(void* address) { 629 size_t largest_size = 0; 630 MemMap* largest_map = nullptr; 631 DCHECK(maps_ != nullptr); 632 for (auto it = maps_->lower_bound(address), end = maps_->end(); 633 it != end && it->first == address; ++it) { 634 MemMap* map = it->second; 635 CHECK(map != nullptr); 636 if (largest_size < map->BaseSize()) { 637 largest_size = map->BaseSize(); 638 largest_map = map; 639 } 640 } 641 return largest_map; 642} 643 644void MemMap::Init() { 645 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 646 if (maps_ == nullptr) { 647 // dex2oat calls MemMap::Init twice since its needed before the runtime is created. 648 maps_ = new Maps; 649 } 650} 651 652void MemMap::Shutdown() { 653 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 654 delete maps_; 655 maps_ = nullptr; 656} 657 658std::ostream& operator<<(std::ostream& os, const MemMap& mem_map) { 659 os << StringPrintf("[MemMap: %p-%p prot=0x%x %s]", 660 mem_map.BaseBegin(), mem_map.BaseEnd(), mem_map.GetProtect(), 661 mem_map.GetName().c_str()); 662 return os; 663} 664 665} // namespace art 666