blob: 8303f845a8f4cfc06334b9b1c0e91214175d914a [file] [log] [blame]
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001/*
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
Christopher Ferris943af7d2014-01-16 12:41:46 -080019#include <backtrace/BacktraceMap.h>
Ian Rogersc7dd2952014-10-21 23:31:19 -070020#include <inttypes.h>
21
Ian Rogers700a4022014-05-19 16:49:03 -070022#include <memory>
Ian Rogersc7dd2952014-10-21 23:31:19 -070023#include <sstream>
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070024
Andreas Gamped8f26db2014-05-19 17:01:13 -070025// See CreateStartPos below.
26#ifdef __BIONIC__
27#include <sys/auxv.h>
28#endif
29
Elliott Hughese222ee02012-12-13 14:41:43 -080030#include "base/stringprintf.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -080031
32#pragma GCC diagnostic push
33#pragma GCC diagnostic ignored "-Wshadow"
Elliott Hughese222ee02012-12-13 14:41:43 -080034#include "ScopedFd.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -080035#pragma GCC diagnostic pop
36
Ian Rogersc7dd2952014-10-21 23:31:19 -070037#include "thread-inl.h"
Elliott Hughese222ee02012-12-13 14:41:43 -080038#include "utils.h"
39
Elliott Hughes6c9c06d2011-11-07 16:43:47 -080040#define USE_ASHMEM 1
41
42#ifdef USE_ASHMEM
43#include <cutils/ashmem.h>
Ian Rogers997f0f92014-06-21 22:58:05 -070044#ifndef ANDROID_OS
45#include <sys/resource.h>
46#endif
Elliott Hughes6c9c06d2011-11-07 16:43:47 -080047#endif
48
Ian Rogersd6b68652014-06-23 14:07:03 -070049#ifndef MAP_ANONYMOUS
50#define MAP_ANONYMOUS MAP_ANON
51#endif
52
Brian Carlstrom27ec9612011-09-19 20:20:38 -070053namespace art {
54
Christopher Ferris943af7d2014-01-16 12:41:46 -080055static 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());
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070065 }
66 return os;
Brian Carlstrom27ec9612011-09-19 20:20:38 -070067}
68
Mathieu Chartierbad02672014-08-25 13:08:22 -070069std::ostream& operator<<(std::ostream& os, const MemMap::Maps& mem_maps) {
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -070070 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
Mathieu Chartier6e88ef62014-10-14 15:01:24 -070080MemMap::Maps* MemMap::maps_ = nullptr;
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -070081
Ian Rogersc3ccc102014-06-25 11:52:14 -070082#if USE_ART_LOW_4G_ALLOCATOR
Andreas Gamped8f26db2014-05-19 17:01:13 -070083// 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.
Andreas Gampe6bd621a2014-05-16 17:28:58 -070086static constexpr uintptr_t LOW_MEM_START = 64 * KB;
Andreas Gampe7104cbf2014-03-21 11:44:43 -070087
Andreas Gamped8f26db2014-05-19 17:01:13 -070088// 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();
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000138#endif
139
Jim_Guoa62a5882014-04-28 11:11:57 +0800140// Return true if the address range is contained in a single /proc/self/map entry.
Narayan Kamathb89c3da2014-08-21 17:38:09 +0100141static bool ContainedWithinExistingMap(uintptr_t begin,
142 uintptr_t end,
143 std::string* error_msg) {
Jim_Guoa62a5882014-04-28 11:11:57 +0800144 std::unique_ptr<BacktraceMap> map(BacktraceMap::Create(getpid(), true));
Christopher Ferris836572a2014-08-05 15:43:13 -0700145 if (map.get() == nullptr) {
Jim_Guoa62a5882014-04-28 11:11:57 +0800146 *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));
Christopher Ferris836572a2014-08-05 15:43:13 -0700168 if (map.get() == nullptr) {
Jim_Guoa62a5882014-04-28 11:11:57 +0800169 *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.
Ian Rogers13735952014-10-08 12:43:28 -0700199static bool CheckMapRequest(uint8_t* expected_ptr, void* actual_ptr, size_t byte_count,
Jim_Guoa62a5882014-04-28 11:11:57 +0800200 std::string* error_msg) {
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700201 // Handled first by caller for more specific error messages.
202 CHECK(actual_ptr != MAP_FAILED);
203
204 if (expected_ptr == nullptr) {
205 return true;
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700206 }
Elliott Hughesecd3a6f2012-06-06 18:16:37 -0700207
Jim_Guoa62a5882014-04-28 11:11:57 +0800208 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
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700212 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
Narayan Kamathb89c3da2014-08-21 17:38:09 +0100222 // 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;
Christopher Ferris943af7d2014-01-16 12:41:46 -0800238 }
Jim_Guoa62a5882014-04-28 11:11:57 +0800239
Narayan Kamathb89c3da2014-08-21 17:38:09 +0100240 *error_msg = os.str();
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700241 return false;
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700242}
243
Ian Rogers13735952014-10-08 12:43:28 -0700244MemMap* MemMap::MapAnonymous(const char* name, uint8_t* expected_ptr, size_t byte_count, int prot,
Ian Rogersef7d42f2014-01-06 12:55:46 -0800245 bool low_4gb, std::string* error_msg) {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700246#ifndef __LP64__
247 UNUSED(low_4gb);
248#endif
Brian Carlstrom9004cb62013-07-26 15:48:31 -0700249 if (byte_count == 0) {
Jim_Guoa62a5882014-04-28 11:11:57 +0800250 return new MemMap(name, nullptr, 0, nullptr, 0, prot, false);
Brian Carlstrom9004cb62013-07-26 15:48:31 -0700251 }
Elliott Hughesecd3a6f2012-06-06 18:16:37 -0700252 size_t page_aligned_byte_count = RoundUp(byte_count, kPageSize);
Elliott Hughes6c9c06d2011-11-07 16:43:47 -0800253
Elliott Hughes6c9c06d2011-11-07 16:43:47 -0800254 int flags = MAP_PRIVATE | MAP_ANONYMOUS;
Ian Rogers997f0f92014-06-21 22:58:05 -0700255 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 }
Elliott Hughes6c9c06d2011-11-07 16:43:47 -0800280#endif
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000281
Brian Carlstromaa94cf32014-03-23 23:47:25 -0700282 // We need to store and potentially set an error number for pretty printing of errors
283 int saved_errno = 0;
284
Qiming Shi84d49cc2014-04-24 15:38:41 +0800285#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.
Jim_Guoa62a5882014-04-28 11:11:57 +0800290 (reinterpret_cast<uintptr_t>(expected_ptr) >> 32) != 0 ||
Qiming Shi84d49cc2014-04-24 15:38:41 +0800291 // End out of bounds. For simplicity, this will fail for the last page of memory.
Jim_Guoa62a5882014-04-28 11:11:57 +0800292 (reinterpret_cast<uintptr_t>(expected_ptr + page_aligned_byte_count) >> 32) != 0)) {
Qiming Shi84d49cc2014-04-24 15:38:41 +0800293 *error_msg = StringPrintf("The requested address space (%p, %p) cannot fit in low_4gb",
Jim_Guoa62a5882014-04-28 11:11:57 +0800294 expected_ptr, expected_ptr + page_aligned_byte_count);
Qiming Shi84d49cc2014-04-24 15:38:41 +0800295 return nullptr;
296 }
297#endif
298
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000299 // 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
Ian Rogersc3ccc102014-06-25 11:52:14 -0700303#if USE_ART_LOW_4G_ALLOCATOR
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000304 // MAP_32BIT only available on x86_64.
305 void* actual = MAP_FAILED;
Jim_Guoa62a5882014-04-28 11:11:57 +0800306 if (low_4gb && expected_ptr == nullptr) {
Andreas Gampe7104cbf2014-03-21 11:44:43 -0700307 bool first_run = true;
308
Andreas Gampe71a3eba2014-03-17 12:57:08 -0700309 for (uintptr_t ptr = next_mem_pos_; ptr < 4 * GB; ptr += kPageSize) {
Andreas Gampe7104cbf2014-03-21 11:44:43 -0700310 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;
Andreas Gampe9de65ff2014-03-21 17:25:57 -0700314 ptr = LOW_MEM_START - kPageSize;
Andreas Gampe7104cbf2014-03-21 11:44:43 -0700315 first_run = false;
316 continue;
317 } else {
318 // Second try failed.
319 break;
320 }
321 }
322
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000323 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) {
Mathieu Chartierc355a2a2014-05-30 13:02:46 -0700342 // 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 }
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000350 }
351 } else {
352 // Skip over last page.
353 ptr = tail_ptr;
354 }
355 }
356
357 if (actual == MAP_FAILED) {
Brian Carlstromaa94cf32014-03-23 23:47:25 -0700358 LOG(ERROR) << "Could not find contiguous low-memory space.";
359 saved_errno = ENOMEM;
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000360 }
361 } else {
Jim_Guoa62a5882014-04-28 11:11:57 +0800362 actual = mmap(expected_ptr, page_aligned_byte_count, prot, flags, fd.get(), 0);
Brian Carlstromaa94cf32014-03-23 23:47:25 -0700363 saved_errno = errno;
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000364 }
365
366#else
Ian Rogersc3ccc102014-06-25 11:52:14 -0700367#if defined(__LP64__)
Jim_Guoa62a5882014-04-28 11:11:57 +0800368 if (low_4gb && expected_ptr == nullptr) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800369 flags |= MAP_32BIT;
370 }
371#endif
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700372
Jim_Guoa62a5882014-04-28 11:11:57 +0800373 void* actual = mmap(expected_ptr, page_aligned_byte_count, prot, flags, fd.get(), 0);
Brian Carlstromaa94cf32014-03-23 23:47:25 -0700374 saved_errno = errno;
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000375#endif
376
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700377 if (actual == MAP_FAILED) {
jeffhao8161c032012-10-31 15:50:00 -0700378 std::string maps;
379 ReadFileToString("/proc/self/maps", &maps);
Brian Carlstromaa94cf32014-03-23 23:47:25 -0700380
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700381 *error_msg = StringPrintf("Failed anonymous mmap(%p, %zd, 0x%x, 0x%x, %d, 0): %s\n%s",
Jim_Guoa62a5882014-04-28 11:11:57 +0800382 expected_ptr, page_aligned_byte_count, prot, flags, fd.get(),
Brian Carlstromaa94cf32014-03-23 23:47:25 -0700383 strerror(saved_errno), maps.c_str());
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700384 return nullptr;
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700385 }
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700386 std::ostringstream check_map_request_error_msg;
Jim_Guoa62a5882014-04-28 11:11:57 +0800387 if (!CheckMapRequest(expected_ptr, actual, page_aligned_byte_count, error_msg)) {
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700388 return nullptr;
389 }
Ian Rogers13735952014-10-08 12:43:28 -0700390 return new MemMap(name, reinterpret_cast<uint8_t*>(actual), byte_count, actual,
Jim_Guoa62a5882014-04-28 11:11:57 +0800391 page_aligned_byte_count, prot, false);
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700392}
393
Ian Rogers13735952014-10-08 12:43:28 -0700394MemMap* MemMap::MapFileAtAddress(uint8_t* expected_ptr, size_t byte_count, int prot, int flags, int fd,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700395 off_t start, bool reuse, const char* filename,
396 std::string* error_msg) {
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700397 CHECK_NE(0, prot);
398 CHECK_NE(0, flags & (MAP_SHARED | MAP_PRIVATE));
Jim_Guoa62a5882014-04-28 11:11:57 +0800399 uintptr_t expected = reinterpret_cast<uintptr_t>(expected_ptr);
400 uintptr_t limit = expected + byte_count;
Narayan Kamathb89c3da2014-08-21 17:38:09 +0100401
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.
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700404 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.
Jim_Guoa62a5882014-04-28 11:11:57 +0800407 CHECK(expected_ptr != nullptr);
Narayan Kamathb89c3da2014-08-21 17:38:09 +0100408
409 DCHECK(ContainedWithinExistingMap(expected, limit, error_msg));
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700410 flags |= MAP_FIXED;
411 } else {
412 CHECK_EQ(0, flags & MAP_FIXED);
Narayan Kamathb89c3da2014-08-21 17:38:09 +0100413 // Don't bother checking for an overlapping region here. We'll
414 // check this if required after the fact inside CheckMapRequest.
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700415 }
416
Brian Carlstrom9004cb62013-07-26 15:48:31 -0700417 if (byte_count == 0) {
Jim_Guoa62a5882014-04-28 11:11:57 +0800418 return new MemMap(filename, nullptr, 0, nullptr, 0, prot, false);
Brian Carlstrom9004cb62013-07-26 15:48:31 -0700419 }
Ian Rogersf8adc602013-04-18 17:06:19 -0700420 // Adjust 'offset' to be page-aligned as required by mmap.
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700421 int page_offset = start % kPageSize;
422 off_t page_aligned_offset = start - page_offset;
Ian Rogersf8adc602013-04-18 17:06:19 -0700423 // Adjust 'byte_count' to be page-aligned as we will map this anyway.
Elliott Hughesecd3a6f2012-06-06 18:16:37 -0700424 size_t page_aligned_byte_count = RoundUp(byte_count + page_offset, kPageSize);
Jim_Guoa62a5882014-04-28 11:11:57 +0800425 // 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.
Ian Rogers13735952014-10-08 12:43:28 -0700427 uint8_t* page_aligned_expected = (expected_ptr == nullptr) ? nullptr : (expected_ptr - page_offset);
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700428
Ian Rogers13735952014-10-08 12:43:28 -0700429 uint8_t* actual = reinterpret_cast<uint8_t*>(mmap(page_aligned_expected,
Elliott Hughesecd3a6f2012-06-06 18:16:37 -0700430 page_aligned_byte_count,
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700431 prot,
432 flags,
433 fd,
434 page_aligned_offset));
435 if (actual == MAP_FAILED) {
Brian Carlstromaa94cf32014-03-23 23:47:25 -0700436 auto saved_errno = errno;
437
jeffhao8161c032012-10-31 15:50:00 -0700438 std::string maps;
439 ReadFileToString("/proc/self/maps", &maps);
Brian Carlstromaa94cf32014-03-23 23:47:25 -0700440
Mathieu Chartierc7cb1902014-03-05 14:41:03 -0800441 *error_msg = StringPrintf("mmap(%p, %zd, 0x%x, 0x%x, %d, %" PRId64
442 ") of file '%s' failed: %s\n%s",
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700443 page_aligned_expected, page_aligned_byte_count, prot, flags, fd,
Brian Carlstromaa94cf32014-03-23 23:47:25 -0700444 static_cast<int64_t>(page_aligned_offset), filename,
445 strerror(saved_errno), maps.c_str());
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700446 return nullptr;
447 }
448 std::ostringstream check_map_request_error_msg;
Jim_Guoa62a5882014-04-28 11:11:57 +0800449 if (!CheckMapRequest(expected_ptr, actual, page_aligned_byte_count, error_msg)) {
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700450 return nullptr;
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700451 }
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800452 return new MemMap(filename, actual + page_offset, byte_count, actual, page_aligned_byte_count,
Jim_Guoa62a5882014-04-28 11:11:57 +0800453 prot, reuse);
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700454}
455
456MemMap::~MemMap() {
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700457 if (base_begin_ == nullptr && base_size_ == 0) {
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700458 return;
459 }
Jim_Guoa62a5882014-04-28 11:11:57 +0800460 if (!reuse_) {
461 int result = munmap(base_begin_, base_size_);
462 if (result == -1) {
463 PLOG(FATAL) << "munmap failed";
464 }
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700465 }
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700466
467 // Remove it from maps_.
468 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_);
469 bool found = false;
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700470 DCHECK(maps_ != nullptr);
471 for (auto it = maps_->lower_bound(base_begin_), end = maps_->end();
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700472 it != end && it->first == base_begin_; ++it) {
473 if (it->second == this) {
474 found = true;
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700475 maps_->erase(it);
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700476 break;
477 }
478 }
479 CHECK(found) << "MemMap not found";
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700480}
481
Ian Rogers13735952014-10-08 12:43:28 -0700482MemMap::MemMap(const std::string& name, uint8_t* begin, size_t size, void* base_begin,
Jim_Guoa62a5882014-04-28 11:11:57 +0800483 size_t base_size, int prot, bool reuse)
Mathieu Chartier1c23e1e2012-10-12 14:14:11 -0700484 : name_(name), begin_(begin), size_(size), base_begin_(base_begin), base_size_(base_size),
Jim_Guoa62a5882014-04-28 11:11:57 +0800485 prot_(prot), reuse_(reuse) {
Brian Carlstrom9004cb62013-07-26 15:48:31 -0700486 if (size_ == 0) {
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700487 CHECK(begin_ == nullptr);
488 CHECK(base_begin_ == nullptr);
Brian Carlstrom9004cb62013-07-26 15:48:31 -0700489 CHECK_EQ(base_size_, 0U);
490 } else {
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700491 CHECK(begin_ != nullptr);
492 CHECK(base_begin_ != nullptr);
Brian Carlstrom9004cb62013-07-26 15:48:31 -0700493 CHECK_NE(base_size_, 0U);
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700494
495 // Add it to maps_.
496 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_);
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700497 DCHECK(maps_ != nullptr);
498 maps_->insert(std::make_pair(base_begin_, this));
Brian Carlstrom9004cb62013-07-26 15:48:31 -0700499 }
Andreas Gampec8ccf682014-09-29 20:07:43 -0700500}
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700501
Ian Rogers13735952014-10-08 12:43:28 -0700502MemMap* MemMap::RemapAtEnd(uint8_t* new_end, const char* tail_name, int tail_prot,
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700503 std::string* error_msg) {
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700504 DCHECK_GE(new_end, Begin());
505 DCHECK_LE(new_end, End());
Ian Rogers13735952014-10-08 12:43:28 -0700506 DCHECK_LE(begin_ + size_, reinterpret_cast<uint8_t*>(base_begin_) + base_size_);
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700507 DCHECK(IsAligned<kPageSize>(begin_));
508 DCHECK(IsAligned<kPageSize>(base_begin_));
Ian Rogers13735952014-10-08 12:43:28 -0700509 DCHECK(IsAligned<kPageSize>(reinterpret_cast<uint8_t*>(base_begin_) + base_size_));
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700510 DCHECK(IsAligned<kPageSize>(new_end));
Ian Rogers13735952014-10-08 12:43:28 -0700511 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;
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700514 DCHECK_LE(new_base_end, old_base_end);
515 if (new_base_end == old_base_end) {
Jim_Guoa62a5882014-04-28 11:11:57 +0800516 return new MemMap(tail_name, nullptr, 0, nullptr, 0, tail_prot, false);
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700517 }
Ian Rogers13735952014-10-08 12:43:28 -0700518 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_);
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700521 size_t tail_size = old_end - new_end;
Ian Rogers13735952014-10-08 12:43:28 -0700522 uint8_t* tail_base_begin = new_base_end;
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700523 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));
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000533 int flags = MAP_PRIVATE | MAP_FIXED;
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700534 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.
Ian Rogers13735952014-10-08 12:43:28 -0700558 uint8_t* actual = reinterpret_cast<uint8_t*>(mmap(tail_base_begin, tail_base_size, tail_prot,
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700559 flags, fd.get(), 0));
560 if (actual == MAP_FAILED) {
561 std::string maps;
562 ReadFileToString("/proc/self/maps", &maps);
Mathieu Chartierc7cb1902014-03-05 14:41:03 -0800563 *error_msg = StringPrintf("anonymous mmap(%p, %zd, 0x%x, 0x%x, %d, 0) failed\n%s",
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700564 tail_base_begin, tail_base_size, tail_prot, flags, fd.get(),
565 maps.c_str());
566 return nullptr;
567 }
Jim_Guoa62a5882014-04-28 11:11:57 +0800568 return new MemMap(tail_name, actual, tail_size, actual, tail_base_size, tail_prot, false);
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700569}
Logan Chiend88fa262012-06-06 15:23:32 +0800570
Ian Rogersc5f17732014-06-05 20:48:42 -0700571void 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
Logan Chiend88fa262012-06-06 15:23:32 +0800583bool MemMap::Protect(int prot) {
Hiroshi Yamauchi4fb5df82014-03-13 15:10:27 -0700584 if (base_begin_ == nullptr && base_size_ == 0) {
Ian Rogers1c849e52012-06-28 14:00:33 -0700585 prot_ = prot;
Logan Chiend88fa262012-06-06 15:23:32 +0800586 return true;
587 }
588
589 if (mprotect(base_begin_, base_size_, prot) == 0) {
Ian Rogers1c849e52012-06-28 14:00:33 -0700590 prot_ = prot;
Logan Chiend88fa262012-06-06 15:23:32 +0800591 return true;
592 }
593
Shih-wei Liaoa060ed92012-06-07 09:25:28 -0700594 PLOG(ERROR) << "mprotect(" << reinterpret_cast<void*>(base_begin_) << ", " << base_size_ << ", "
595 << prot << ") failed";
Logan Chiend88fa262012-06-06 15:23:32 +0800596 return false;
597}
598
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700599bool 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) {
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700619 MutexLock mu(Thread::Current(), *Locks::mem_maps_lock_);
Mathieu Chartierbad02672014-08-25 13:08:22 -0700620 DumpMapsLocked(os);
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700621}
622
Mathieu Chartierbad02672014-08-25 13:08:22 -0700623void MemMap::DumpMapsLocked(std::ostream& os) {
624 os << maps_;
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700625}
626
627bool MemMap::HasMemMap(MemMap* map) {
628 void* base_begin = map->BaseBegin();
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700629 for (auto it = maps_->lower_bound(base_begin), end = maps_->end();
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700630 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;
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700641 DCHECK(maps_ != nullptr);
642 for (auto it = maps_->lower_bound(address), end = maps_->end();
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700643 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
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700654void 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
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800668std::ostream& operator<<(std::ostream& os, const MemMap& mem_map) {
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700669 os << StringPrintf("[MemMap: %p-%p prot=0x%x %s]",
670 mem_map.BaseBegin(), mem_map.BaseEnd(), mem_map.GetProtect(),
671 mem_map.GetName().c_str());
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800672 return os;
673}
674
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700675} // namespace art