mem_map.cc revision 6a3c1fcb4ba42ad4d5d142c17a3712a6ddd3866f
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#ifndef __LP64__ 242 UNUSED(low_4gb); 243#endif 244 if (byte_count == 0) { 245 return new MemMap(name, nullptr, 0, nullptr, 0, prot, false); 246 } 247 size_t page_aligned_byte_count = RoundUp(byte_count, kPageSize); 248 249 int flags = MAP_PRIVATE | MAP_ANONYMOUS; 250 ScopedFd fd(-1); 251 252#ifdef USE_ASHMEM 253#ifdef HAVE_ANDROID_OS 254 const bool use_ashmem = true; 255#else 256 // When not on Android ashmem is faked using files in /tmp. Ensure that such files won't 257 // fail due to ulimit restrictions. If they will then use a regular mmap. 258 struct rlimit rlimit_fsize; 259 CHECK_EQ(getrlimit(RLIMIT_FSIZE, &rlimit_fsize), 0); 260 const bool use_ashmem = (rlimit_fsize.rlim_cur == RLIM_INFINITY) || 261 (page_aligned_byte_count < rlimit_fsize.rlim_cur); 262#endif 263 if (use_ashmem) { 264 // android_os_Debug.cpp read_mapinfo assumes all ashmem regions associated with the VM are 265 // prefixed "dalvik-". 266 std::string debug_friendly_name("dalvik-"); 267 debug_friendly_name += name; 268 fd.reset(ashmem_create_region(debug_friendly_name.c_str(), page_aligned_byte_count)); 269 if (fd.get() == -1) { 270 *error_msg = StringPrintf("ashmem_create_region failed for '%s': %s", name, strerror(errno)); 271 return nullptr; 272 } 273 flags = MAP_PRIVATE; 274 } 275#endif 276 277 // We need to store and potentially set an error number for pretty printing of errors 278 int saved_errno = 0; 279 280#ifdef __LP64__ 281 // When requesting low_4g memory and having an expectation, the requested range should fit into 282 // 4GB. 283 if (low_4gb && ( 284 // Start out of bounds. 285 (reinterpret_cast<uintptr_t>(expected_ptr) >> 32) != 0 || 286 // End out of bounds. For simplicity, this will fail for the last page of memory. 287 (reinterpret_cast<uintptr_t>(expected_ptr + page_aligned_byte_count) >> 32) != 0)) { 288 *error_msg = StringPrintf("The requested address space (%p, %p) cannot fit in low_4gb", 289 expected_ptr, expected_ptr + page_aligned_byte_count); 290 return nullptr; 291 } 292#endif 293 294 // TODO: 295 // A page allocator would be a useful abstraction here, as 296 // 1) It is doubtful that MAP_32BIT on x86_64 is doing the right job for us 297 // 2) The linear scheme, even with simple saving of the last known position, is very crude 298#if USE_ART_LOW_4G_ALLOCATOR 299 // MAP_32BIT only available on x86_64. 300 void* actual = MAP_FAILED; 301 if (low_4gb && expected_ptr == nullptr) { 302 bool first_run = true; 303 304 for (uintptr_t ptr = next_mem_pos_; ptr < 4 * GB; ptr += kPageSize) { 305 if (4U * GB - ptr < page_aligned_byte_count) { 306 // Not enough memory until 4GB. 307 if (first_run) { 308 // Try another time from the bottom; 309 ptr = LOW_MEM_START - kPageSize; 310 first_run = false; 311 continue; 312 } else { 313 // Second try failed. 314 break; 315 } 316 } 317 318 uintptr_t tail_ptr; 319 320 // Check pages are free. 321 bool safe = true; 322 for (tail_ptr = ptr; tail_ptr < ptr + page_aligned_byte_count; tail_ptr += kPageSize) { 323 if (msync(reinterpret_cast<void*>(tail_ptr), kPageSize, 0) == 0) { 324 safe = false; 325 break; 326 } else { 327 DCHECK_EQ(errno, ENOMEM); 328 } 329 } 330 331 next_mem_pos_ = tail_ptr; // update early, as we break out when we found and mapped a region 332 333 if (safe == true) { 334 actual = mmap(reinterpret_cast<void*>(ptr), page_aligned_byte_count, prot, flags, fd.get(), 335 0); 336 if (actual != MAP_FAILED) { 337 // Since we didn't use MAP_FIXED the kernel may have mapped it somewhere not in the low 338 // 4GB. If this is the case, unmap and retry. 339 if (reinterpret_cast<uintptr_t>(actual) + page_aligned_byte_count < 4 * GB) { 340 break; 341 } else { 342 munmap(actual, page_aligned_byte_count); 343 actual = MAP_FAILED; 344 } 345 } 346 } else { 347 // Skip over last page. 348 ptr = tail_ptr; 349 } 350 } 351 352 if (actual == MAP_FAILED) { 353 LOG(ERROR) << "Could not find contiguous low-memory space."; 354 saved_errno = ENOMEM; 355 } 356 } else { 357 actual = mmap(expected_ptr, page_aligned_byte_count, prot, flags, fd.get(), 0); 358 saved_errno = errno; 359 } 360 361#else 362#if defined(__LP64__) 363 if (low_4gb && expected_ptr == nullptr) { 364 flags |= MAP_32BIT; 365 } 366#endif 367 368 void* actual = mmap(expected_ptr, page_aligned_byte_count, prot, flags, fd.get(), 0); 369 saved_errno = errno; 370#endif 371 372 if (actual == MAP_FAILED) { 373 std::string maps; 374 ReadFileToString("/proc/self/maps", &maps); 375 376 *error_msg = StringPrintf("Failed anonymous mmap(%p, %zd, 0x%x, 0x%x, %d, 0): %s\n%s", 377 expected_ptr, page_aligned_byte_count, prot, flags, fd.get(), 378 strerror(saved_errno), maps.c_str()); 379 return nullptr; 380 } 381 std::ostringstream check_map_request_error_msg; 382 if (!CheckMapRequest(expected_ptr, actual, page_aligned_byte_count, error_msg)) { 383 return nullptr; 384 } 385 return new MemMap(name, reinterpret_cast<uint8_t*>(actual), byte_count, actual, 386 page_aligned_byte_count, prot, false); 387} 388 389MemMap* MemMap::MapFileAtAddress(uint8_t* expected_ptr, size_t byte_count, int prot, int flags, int fd, 390 off_t start, bool reuse, const char* filename, 391 std::string* error_msg) { 392 CHECK_NE(0, prot); 393 CHECK_NE(0, flags & (MAP_SHARED | MAP_PRIVATE)); 394 uintptr_t expected = reinterpret_cast<uintptr_t>(expected_ptr); 395 uintptr_t limit = expected + byte_count; 396 397 // Note that we do not allow MAP_FIXED unless reuse == true, i.e we 398 // expect his mapping to be contained within an existing map. 399 if (reuse) { 400 // reuse means it is okay that it overlaps an existing page mapping. 401 // Only use this if you actually made the page reservation yourself. 402 CHECK(expected_ptr != nullptr); 403 404 DCHECK(ContainedWithinExistingMap(expected, limit, error_msg)); 405 flags |= MAP_FIXED; 406 } else { 407 CHECK_EQ(0, flags & MAP_FIXED); 408 // Don't bother checking for an overlapping region here. We'll 409 // check this if required after the fact inside CheckMapRequest. 410 } 411 412 if (byte_count == 0) { 413 return new MemMap(filename, nullptr, 0, nullptr, 0, prot, false); 414 } 415 // Adjust 'offset' to be page-aligned as required by mmap. 416 int page_offset = start % kPageSize; 417 off_t page_aligned_offset = start - page_offset; 418 // Adjust 'byte_count' to be page-aligned as we will map this anyway. 419 size_t page_aligned_byte_count = RoundUp(byte_count + page_offset, kPageSize); 420 // The 'expected_ptr' is modified (if specified, ie non-null) to be page aligned to the file but 421 // not necessarily to virtual memory. mmap will page align 'expected' for us. 422 uint8_t* page_aligned_expected = (expected_ptr == nullptr) ? nullptr : (expected_ptr - page_offset); 423 424 uint8_t* actual = reinterpret_cast<uint8_t*>(mmap(page_aligned_expected, 425 page_aligned_byte_count, 426 prot, 427 flags, 428 fd, 429 page_aligned_offset)); 430 if (actual == MAP_FAILED) { 431 auto saved_errno = errno; 432 433 std::string maps; 434 ReadFileToString("/proc/self/maps", &maps); 435 436 *error_msg = StringPrintf("mmap(%p, %zd, 0x%x, 0x%x, %d, %" PRId64 437 ") of file '%s' failed: %s\n%s", 438 page_aligned_expected, page_aligned_byte_count, prot, flags, fd, 439 static_cast<int64_t>(page_aligned_offset), filename, 440 strerror(saved_errno), maps.c_str()); 441 return nullptr; 442 } 443 std::ostringstream check_map_request_error_msg; 444 if (!CheckMapRequest(expected_ptr, actual, page_aligned_byte_count, error_msg)) { 445 return nullptr; 446 } 447 return new MemMap(filename, actual + page_offset, byte_count, actual, page_aligned_byte_count, 448 prot, reuse); 449} 450 451MemMap::~MemMap() { 452 if (base_begin_ == nullptr && base_size_ == 0) { 453 return; 454 } 455 if (!reuse_) { 456 int result = munmap(base_begin_, base_size_); 457 if (result == -1) { 458 PLOG(FATAL) << "munmap failed"; 459 } 460 } 461 462 // Remove it from maps_. 463 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 464 bool found = false; 465 DCHECK(maps_ != nullptr); 466 for (auto it = maps_->lower_bound(base_begin_), end = maps_->end(); 467 it != end && it->first == base_begin_; ++it) { 468 if (it->second == this) { 469 found = true; 470 maps_->erase(it); 471 break; 472 } 473 } 474 CHECK(found) << "MemMap not found"; 475} 476 477MemMap::MemMap(const std::string& name, uint8_t* begin, size_t size, void* base_begin, 478 size_t base_size, int prot, bool reuse) 479 : name_(name), begin_(begin), size_(size), base_begin_(base_begin), base_size_(base_size), 480 prot_(prot), reuse_(reuse) { 481 if (size_ == 0) { 482 CHECK(begin_ == nullptr); 483 CHECK(base_begin_ == nullptr); 484 CHECK_EQ(base_size_, 0U); 485 } else { 486 CHECK(begin_ != nullptr); 487 CHECK(base_begin_ != nullptr); 488 CHECK_NE(base_size_, 0U); 489 490 // Add it to maps_. 491 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 492 DCHECK(maps_ != nullptr); 493 maps_->insert(std::make_pair(base_begin_, this)); 494 } 495} 496 497MemMap* MemMap::RemapAtEnd(uint8_t* new_end, const char* tail_name, int tail_prot, 498 std::string* error_msg) { 499 DCHECK_GE(new_end, Begin()); 500 DCHECK_LE(new_end, End()); 501 DCHECK_LE(begin_ + size_, reinterpret_cast<uint8_t*>(base_begin_) + base_size_); 502 DCHECK(IsAligned<kPageSize>(begin_)); 503 DCHECK(IsAligned<kPageSize>(base_begin_)); 504 DCHECK(IsAligned<kPageSize>(reinterpret_cast<uint8_t*>(base_begin_) + base_size_)); 505 DCHECK(IsAligned<kPageSize>(new_end)); 506 uint8_t* old_end = begin_ + size_; 507 uint8_t* old_base_end = reinterpret_cast<uint8_t*>(base_begin_) + base_size_; 508 uint8_t* new_base_end = new_end; 509 DCHECK_LE(new_base_end, old_base_end); 510 if (new_base_end == old_base_end) { 511 return new MemMap(tail_name, nullptr, 0, nullptr, 0, tail_prot, false); 512 } 513 size_ = new_end - reinterpret_cast<uint8_t*>(begin_); 514 base_size_ = new_base_end - reinterpret_cast<uint8_t*>(base_begin_); 515 DCHECK_LE(begin_ + size_, reinterpret_cast<uint8_t*>(base_begin_) + base_size_); 516 size_t tail_size = old_end - new_end; 517 uint8_t* tail_base_begin = new_base_end; 518 size_t tail_base_size = old_base_end - new_base_end; 519 DCHECK_EQ(tail_base_begin + tail_base_size, old_base_end); 520 DCHECK(IsAligned<kPageSize>(tail_base_size)); 521 522#ifdef USE_ASHMEM 523 // android_os_Debug.cpp read_mapinfo assumes all ashmem regions associated with the VM are 524 // prefixed "dalvik-". 525 std::string debug_friendly_name("dalvik-"); 526 debug_friendly_name += tail_name; 527 ScopedFd fd(ashmem_create_region(debug_friendly_name.c_str(), tail_base_size)); 528 int flags = MAP_PRIVATE | MAP_FIXED; 529 if (fd.get() == -1) { 530 *error_msg = StringPrintf("ashmem_create_region failed for '%s': %s", 531 tail_name, strerror(errno)); 532 return nullptr; 533 } 534#else 535 ScopedFd fd(-1); 536 int flags = MAP_PRIVATE | MAP_ANONYMOUS; 537#endif 538 539 // Unmap/map the tail region. 540 int result = munmap(tail_base_begin, tail_base_size); 541 if (result == -1) { 542 std::string maps; 543 ReadFileToString("/proc/self/maps", &maps); 544 *error_msg = StringPrintf("munmap(%p, %zd) failed for '%s'\n%s", 545 tail_base_begin, tail_base_size, name_.c_str(), 546 maps.c_str()); 547 return nullptr; 548 } 549 // Don't cause memory allocation between the munmap and the mmap 550 // calls. Otherwise, libc (or something else) might take this memory 551 // region. Note this isn't perfect as there's no way to prevent 552 // other threads to try to take this memory region here. 553 uint8_t* actual = reinterpret_cast<uint8_t*>(mmap(tail_base_begin, tail_base_size, tail_prot, 554 flags, fd.get(), 0)); 555 if (actual == MAP_FAILED) { 556 std::string maps; 557 ReadFileToString("/proc/self/maps", &maps); 558 *error_msg = StringPrintf("anonymous mmap(%p, %zd, 0x%x, 0x%x, %d, 0) failed\n%s", 559 tail_base_begin, tail_base_size, tail_prot, flags, fd.get(), 560 maps.c_str()); 561 return nullptr; 562 } 563 return new MemMap(tail_name, actual, tail_size, actual, tail_base_size, tail_prot, false); 564} 565 566void MemMap::MadviseDontNeedAndZero() { 567 if (base_begin_ != nullptr || base_size_ != 0) { 568 if (!kMadviseZeroes) { 569 memset(base_begin_, 0, base_size_); 570 } 571 int result = madvise(base_begin_, base_size_, MADV_DONTNEED); 572 if (result == -1) { 573 PLOG(WARNING) << "madvise failed"; 574 } 575 } 576} 577 578bool MemMap::Protect(int prot) { 579 if (base_begin_ == nullptr && base_size_ == 0) { 580 prot_ = prot; 581 return true; 582 } 583 584 if (mprotect(base_begin_, base_size_, prot) == 0) { 585 prot_ = prot; 586 return true; 587 } 588 589 PLOG(ERROR) << "mprotect(" << reinterpret_cast<void*>(base_begin_) << ", " << base_size_ << ", " 590 << prot << ") failed"; 591 return false; 592} 593 594bool MemMap::CheckNoGaps(MemMap* begin_map, MemMap* end_map) { 595 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 596 CHECK(begin_map != nullptr); 597 CHECK(end_map != nullptr); 598 CHECK(HasMemMap(begin_map)); 599 CHECK(HasMemMap(end_map)); 600 CHECK_LE(begin_map->BaseBegin(), end_map->BaseBegin()); 601 MemMap* map = begin_map; 602 while (map->BaseBegin() != end_map->BaseBegin()) { 603 MemMap* next_map = GetLargestMemMapAt(map->BaseEnd()); 604 if (next_map == nullptr) { 605 // Found a gap. 606 return false; 607 } 608 map = next_map; 609 } 610 return true; 611} 612 613void MemMap::DumpMaps(std::ostream& os) { 614 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 615 DumpMapsLocked(os); 616} 617 618void MemMap::DumpMapsLocked(std::ostream& os) { 619 os << maps_; 620} 621 622bool MemMap::HasMemMap(MemMap* map) { 623 void* base_begin = map->BaseBegin(); 624 for (auto it = maps_->lower_bound(base_begin), end = maps_->end(); 625 it != end && it->first == base_begin; ++it) { 626 if (it->second == map) { 627 return true; 628 } 629 } 630 return false; 631} 632 633MemMap* MemMap::GetLargestMemMapAt(void* address) { 634 size_t largest_size = 0; 635 MemMap* largest_map = nullptr; 636 DCHECK(maps_ != nullptr); 637 for (auto it = maps_->lower_bound(address), end = maps_->end(); 638 it != end && it->first == address; ++it) { 639 MemMap* map = it->second; 640 CHECK(map != nullptr); 641 if (largest_size < map->BaseSize()) { 642 largest_size = map->BaseSize(); 643 largest_map = map; 644 } 645 } 646 return largest_map; 647} 648 649void MemMap::Init() { 650 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 651 if (maps_ == nullptr) { 652 // dex2oat calls MemMap::Init twice since its needed before the runtime is created. 653 maps_ = new Maps; 654 } 655} 656 657void MemMap::Shutdown() { 658 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_); 659 delete maps_; 660 maps_ = nullptr; 661} 662 663std::ostream& operator<<(std::ostream& os, const MemMap& mem_map) { 664 os << StringPrintf("[MemMap: %p-%p prot=0x%x %s]", 665 mem_map.BaseBegin(), mem_map.BaseEnd(), mem_map.GetProtect(), 666 mem_map.GetName().c_str()); 667 return os; 668} 669 670} // namespace art 671