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