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 <corkscrew/map_info.h>
20
21 #include "base/stringprintf.h"
22 #include "ScopedFd.h"
23 #include "utils.h"
24
25 #define USE_ASHMEM 1
26
27 #ifdef USE_ASHMEM
28 #include <cutils/ashmem.h>
29 #endif
30
31 namespace art {
32
33 #if !defined(NDEBUG)
34
operator <<(std::ostream & os,map_info_t * rhs)35 static std::ostream& operator<<(std::ostream& os, map_info_t* rhs) {
36 for (map_info_t* m = rhs; m != NULL; m = m->next) {
37 os << StringPrintf("0x%08x-0x%08x %c%c %s\n",
38 static_cast<uint32_t>(m->start),
39 static_cast<uint32_t>(m->end),
40 m->is_readable ? 'r' : '-', m->is_executable ? 'x' : '-', m->name);
41 }
42 return os;
43 }
44
CheckMapRequest(byte * addr,size_t byte_count)45 static void CheckMapRequest(byte* addr, size_t byte_count) {
46 if (addr == NULL) {
47 return;
48 }
49
50 uint32_t base = reinterpret_cast<size_t>(addr);
51 uint32_t limit = base + byte_count;
52
53 map_info_t* map_info_list = load_map_info_list(getpid());
54 for (map_info_t* m = map_info_list; m != NULL; m = m->next) {
55 CHECK(!(base >= m->start && base < m->end) // start of new within old
56 && !(limit > m->start && limit < m->end) // end of new within old
57 && !(base <= m->start && limit > m->end)) // start/end of new includes all of old
58 << StringPrintf("Requested region 0x%08x-0x%08x overlaps with existing map 0x%08x-0x%08x (%s)\n",
59 base, limit,
60 static_cast<uint32_t>(m->start), static_cast<uint32_t>(m->end), m->name)
61 << map_info_list;
62 }
63 free_map_info_list(map_info_list);
64 }
65
66 #else
67 static void CheckMapRequest(byte*, size_t) { }
68 #endif
69
MapAnonymous(const char * name,byte * addr,size_t byte_count,int prot)70 MemMap* MemMap::MapAnonymous(const char* name, byte* addr, size_t byte_count, int prot) {
71 if (byte_count == 0) {
72 return new MemMap(name, NULL, 0, NULL, 0, prot);
73 }
74 size_t page_aligned_byte_count = RoundUp(byte_count, kPageSize);
75 CheckMapRequest(addr, page_aligned_byte_count);
76
77 #ifdef USE_ASHMEM
78 // android_os_Debug.cpp read_mapinfo assumes all ashmem regions associated with the VM are
79 // prefixed "dalvik-".
80 std::string debug_friendly_name("dalvik-");
81 debug_friendly_name += name;
82 ScopedFd fd(ashmem_create_region(debug_friendly_name.c_str(), page_aligned_byte_count));
83 int flags = MAP_PRIVATE;
84 if (fd.get() == -1) {
85 PLOG(ERROR) << "ashmem_create_region failed (" << name << ")";
86 return NULL;
87 }
88 #else
89 ScopedFd fd(-1);
90 int flags = MAP_PRIVATE | MAP_ANONYMOUS;
91 #endif
92
93 byte* actual = reinterpret_cast<byte*>(mmap(addr, page_aligned_byte_count, prot, flags, fd.get(), 0));
94 if (actual == MAP_FAILED) {
95 std::string maps;
96 ReadFileToString("/proc/self/maps", &maps);
97 PLOG(ERROR) << "mmap(" << reinterpret_cast<void*>(addr) << ", " << page_aligned_byte_count
98 << ", " << prot << ", " << flags << ", " << fd.get() << ", 0) failed for " << name
99 << "\n" << maps;
100 return NULL;
101 }
102 return new MemMap(name, actual, byte_count, actual, page_aligned_byte_count, prot);
103 }
104
MapFileAtAddress(byte * addr,size_t byte_count,int prot,int flags,int fd,off_t start,bool reuse)105 MemMap* MemMap::MapFileAtAddress(byte* addr, size_t byte_count,
106 int prot, int flags, int fd, off_t start, bool reuse) {
107 CHECK_NE(0, prot);
108 CHECK_NE(0, flags & (MAP_SHARED | MAP_PRIVATE));
109 if (byte_count == 0) {
110 return new MemMap("file", NULL, 0, NULL, 0, prot);
111 }
112 // Adjust 'offset' to be page-aligned as required by mmap.
113 int page_offset = start % kPageSize;
114 off_t page_aligned_offset = start - page_offset;
115 // Adjust 'byte_count' to be page-aligned as we will map this anyway.
116 size_t page_aligned_byte_count = RoundUp(byte_count + page_offset, kPageSize);
117 // The 'addr' is modified (if specified, ie non-null) to be page aligned to the file but not
118 // necessarily to virtual memory. mmap will page align 'addr' for us.
119 byte* page_aligned_addr = (addr == NULL) ? NULL : (addr - page_offset);
120 if (!reuse) {
121 // reuse means it is okay that it overlaps an existing page mapping.
122 // Only use this if you actually made the page reservation yourself.
123 CheckMapRequest(page_aligned_addr, page_aligned_byte_count);
124 } else {
125 CHECK(addr != NULL);
126 }
127 byte* actual = reinterpret_cast<byte*>(mmap(page_aligned_addr,
128 page_aligned_byte_count,
129 prot,
130 flags,
131 fd,
132 page_aligned_offset));
133 if (actual == MAP_FAILED) {
134 std::string maps;
135 ReadFileToString("/proc/self/maps", &maps);
136 PLOG(ERROR) << "mmap(" << reinterpret_cast<void*>(page_aligned_addr)
137 << ", " << page_aligned_byte_count
138 << ", " << prot << ", " << flags << ", " << fd << ", " << page_aligned_offset
139 << ") failed\n" << maps;
140 return NULL;
141 }
142 return new MemMap("file", actual + page_offset, byte_count, actual, page_aligned_byte_count,
143 prot);
144 }
145
~MemMap()146 MemMap::~MemMap() {
147 if (base_begin_ == NULL && base_size_ == 0) {
148 return;
149 }
150 int result = munmap(base_begin_, base_size_);
151 if (result == -1) {
152 PLOG(FATAL) << "munmap failed";
153 }
154 }
155
MemMap(const std::string & name,byte * begin,size_t size,void * base_begin,size_t base_size,int prot)156 MemMap::MemMap(const std::string& name, byte* begin, size_t size, void* base_begin,
157 size_t base_size, int prot)
158 : name_(name), begin_(begin), size_(size), base_begin_(base_begin), base_size_(base_size),
159 prot_(prot) {
160 if (size_ == 0) {
161 CHECK(begin_ == NULL);
162 CHECK(base_begin_ == NULL);
163 CHECK_EQ(base_size_, 0U);
164 } else {
165 CHECK(begin_ != NULL);
166 CHECK(base_begin_ != NULL);
167 CHECK_NE(base_size_, 0U);
168 }
169 };
170
UnMapAtEnd(byte * new_end)171 void MemMap::UnMapAtEnd(byte* new_end) {
172 DCHECK_GE(new_end, Begin());
173 DCHECK_LE(new_end, End());
174 size_t unmap_size = End() - new_end;
175 munmap(new_end, unmap_size);
176 size_ -= unmap_size;
177 }
178
Protect(int prot)179 bool MemMap::Protect(int prot) {
180 if (base_begin_ == NULL && base_size_ == 0) {
181 prot_ = prot;
182 return true;
183 }
184
185 if (mprotect(base_begin_, base_size_, prot) == 0) {
186 prot_ = prot;
187 return true;
188 }
189
190 PLOG(ERROR) << "mprotect(" << reinterpret_cast<void*>(base_begin_) << ", " << base_size_ << ", "
191 << prot << ") failed";
192 return false;
193 }
194
195 } // namespace art
196