mem_map.cc revision 5369c40f75fdcb1be7a7c06db212ce965c83a164
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_; 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(byte* 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, byte* 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<byte*>(actual), byte_count, actual, 381 page_aligned_byte_count, prot, false); 382} 383 384MemMap* MemMap::MapFileAtAddress(byte* 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 byte* page_aligned_expected = (expected_ptr == nullptr) ? nullptr : (expected_ptr - page_offset); 418 419 byte* actual = reinterpret_cast<byte*>(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 for (auto it = maps_.lower_bound(base_begin_), end = maps_.end(); 461 it != end && it->first == base_begin_; ++it) { 462 if (it->second == this) { 463 found = true; 464 maps_.erase(it); 465 break; 466 } 467 } 468 CHECK(found) << "MemMap not found"; 469} 470 471MemMap::MemMap(const std::string& name, byte* begin, size_t size, void* base_begin, 472 size_t base_size, int prot, bool reuse) 473 : name_(name), begin_(begin), size_(size), base_begin_(base_begin), base_size_(base_size), 474 prot_(prot), reuse_(reuse) { 475 if (size_ == 0) { 476 CHECK(begin_ == nullptr); 477 CHECK(base_begin_ == nullptr); 478 CHECK_EQ(base_size_, 0U); 479 } else { 480 CHECK(begin_ != nullptr); 481 CHECK(base_begin_ != nullptr); 482 CHECK_NE(base_size_, 0U); 483 484 // Add it to maps_. 485 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 486 maps_.insert(std::pair<void*, MemMap*>(base_begin_, this)); 487 } 488}; 489 490MemMap* MemMap::RemapAtEnd(byte* new_end, const char* tail_name, int tail_prot, 491 std::string* error_msg) { 492 DCHECK_GE(new_end, Begin()); 493 DCHECK_LE(new_end, End()); 494 DCHECK_LE(begin_ + size_, reinterpret_cast<byte*>(base_begin_) + base_size_); 495 DCHECK(IsAligned<kPageSize>(begin_)); 496 DCHECK(IsAligned<kPageSize>(base_begin_)); 497 DCHECK(IsAligned<kPageSize>(reinterpret_cast<byte*>(base_begin_) + base_size_)); 498 DCHECK(IsAligned<kPageSize>(new_end)); 499 byte* old_end = begin_ + size_; 500 byte* old_base_end = reinterpret_cast<byte*>(base_begin_) + base_size_; 501 byte* new_base_end = new_end; 502 DCHECK_LE(new_base_end, old_base_end); 503 if (new_base_end == old_base_end) { 504 return new MemMap(tail_name, nullptr, 0, nullptr, 0, tail_prot, false); 505 } 506 size_ = new_end - reinterpret_cast<byte*>(begin_); 507 base_size_ = new_base_end - reinterpret_cast<byte*>(base_begin_); 508 DCHECK_LE(begin_ + size_, reinterpret_cast<byte*>(base_begin_) + base_size_); 509 size_t tail_size = old_end - new_end; 510 byte* tail_base_begin = new_base_end; 511 size_t tail_base_size = old_base_end - new_base_end; 512 DCHECK_EQ(tail_base_begin + tail_base_size, old_base_end); 513 DCHECK(IsAligned<kPageSize>(tail_base_size)); 514 515#ifdef USE_ASHMEM 516 // android_os_Debug.cpp read_mapinfo assumes all ashmem regions associated with the VM are 517 // prefixed "dalvik-". 518 std::string debug_friendly_name("dalvik-"); 519 debug_friendly_name += tail_name; 520 ScopedFd fd(ashmem_create_region(debug_friendly_name.c_str(), tail_base_size)); 521 int flags = MAP_PRIVATE | MAP_FIXED; 522 if (fd.get() == -1) { 523 *error_msg = StringPrintf("ashmem_create_region failed for '%s': %s", 524 tail_name, strerror(errno)); 525 return nullptr; 526 } 527#else 528 ScopedFd fd(-1); 529 int flags = MAP_PRIVATE | MAP_ANONYMOUS; 530#endif 531 532 // Unmap/map the tail region. 533 int result = munmap(tail_base_begin, tail_base_size); 534 if (result == -1) { 535 std::string maps; 536 ReadFileToString("/proc/self/maps", &maps); 537 *error_msg = StringPrintf("munmap(%p, %zd) failed for '%s'\n%s", 538 tail_base_begin, tail_base_size, name_.c_str(), 539 maps.c_str()); 540 return nullptr; 541 } 542 // Don't cause memory allocation between the munmap and the mmap 543 // calls. Otherwise, libc (or something else) might take this memory 544 // region. Note this isn't perfect as there's no way to prevent 545 // other threads to try to take this memory region here. 546 byte* actual = reinterpret_cast<byte*>(mmap(tail_base_begin, tail_base_size, tail_prot, 547 flags, fd.get(), 0)); 548 if (actual == MAP_FAILED) { 549 std::string maps; 550 ReadFileToString("/proc/self/maps", &maps); 551 *error_msg = StringPrintf("anonymous mmap(%p, %zd, 0x%x, 0x%x, %d, 0) failed\n%s", 552 tail_base_begin, tail_base_size, tail_prot, flags, fd.get(), 553 maps.c_str()); 554 return nullptr; 555 } 556 return new MemMap(tail_name, actual, tail_size, actual, tail_base_size, tail_prot, false); 557} 558 559void MemMap::MadviseDontNeedAndZero() { 560 if (base_begin_ != nullptr || base_size_ != 0) { 561 if (!kMadviseZeroes) { 562 memset(base_begin_, 0, base_size_); 563 } 564 int result = madvise(base_begin_, base_size_, MADV_DONTNEED); 565 if (result == -1) { 566 PLOG(WARNING) << "madvise failed"; 567 } 568 } 569} 570 571bool MemMap::Protect(int prot) { 572 if (base_begin_ == nullptr && base_size_ == 0) { 573 prot_ = prot; 574 return true; 575 } 576 577 if (mprotect(base_begin_, base_size_, prot) == 0) { 578 prot_ = prot; 579 return true; 580 } 581 582 PLOG(ERROR) << "mprotect(" << reinterpret_cast<void*>(base_begin_) << ", " << base_size_ << ", " 583 << prot << ") failed"; 584 return false; 585} 586 587bool MemMap::CheckNoGaps(MemMap* begin_map, MemMap* end_map) { 588 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 589 CHECK(begin_map != nullptr); 590 CHECK(end_map != nullptr); 591 CHECK(HasMemMap(begin_map)); 592 CHECK(HasMemMap(end_map)); 593 CHECK_LE(begin_map->BaseBegin(), end_map->BaseBegin()); 594 MemMap* map = begin_map; 595 while (map->BaseBegin() != end_map->BaseBegin()) { 596 MemMap* next_map = GetLargestMemMapAt(map->BaseEnd()); 597 if (next_map == nullptr) { 598 // Found a gap. 599 return false; 600 } 601 map = next_map; 602 } 603 return true; 604} 605 606void MemMap::DumpMaps(std::ostream& os) { 607 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 608 DumpMapsLocked(os); 609} 610 611void MemMap::DumpMapsLocked(std::ostream& os) { 612 os << maps_; 613} 614 615bool MemMap::HasMemMap(MemMap* map) { 616 void* base_begin = map->BaseBegin(); 617 for (auto it = maps_.lower_bound(base_begin), end = maps_.end(); 618 it != end && it->first == base_begin; ++it) { 619 if (it->second == map) { 620 return true; 621 } 622 } 623 return false; 624} 625 626MemMap* MemMap::GetLargestMemMapAt(void* address) { 627 size_t largest_size = 0; 628 MemMap* largest_map = nullptr; 629 for (auto it = maps_.lower_bound(address), end = maps_.end(); 630 it != end && it->first == address; ++it) { 631 MemMap* map = it->second; 632 CHECK(map != nullptr); 633 if (largest_size < map->BaseSize()) { 634 largest_size = map->BaseSize(); 635 largest_map = map; 636 } 637 } 638 return largest_map; 639} 640 641std::ostream& operator<<(std::ostream& os, const MemMap& mem_map) { 642 os << StringPrintf("[MemMap: %p-%p prot=0x%x %s]", 643 mem_map.BaseBegin(), mem_map.BaseEnd(), mem_map.GetProtect(), 644 mem_map.GetName().c_str()); 645 return os; 646} 647 648} // namespace art 649