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