blob: 9e867728ff64aa6841e321e217afbc9c05416317 [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
Elliott Hughes6c9c06d2011-11-07 16:43:47 -080019#include "ScopedFd.h"
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070020#include "stringprintf.h"
Elliott Hughes6c9c06d2011-11-07 16:43:47 -080021#include "utils.h"
22
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070023#include <corkscrew/map_info.h>
24
Elliott Hughes6c9c06d2011-11-07 16:43:47 -080025#define USE_ASHMEM 1
26
27#ifdef USE_ASHMEM
28#include <cutils/ashmem.h>
29#endif
30
Brian Carlstrom27ec9612011-09-19 20:20:38 -070031namespace art {
32
Elliott Hughes96970cd2012-03-13 15:46:31 -070033#if !defined(NDEBUG)
34
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070035static std::ostream& operator<<(std::ostream& os, map_info_t* rhs) {
36 for (map_info_t* m = rhs; m != NULL; m = m->next) {
Elliott Hughes7bda1582012-06-07 11:00:54 -070037 os << StringPrintf("0x%08x-0x%08x %c%c %s\n",
38 static_cast<uint32_t>(m->start),
39 static_cast<uint32_t>(m->end),
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070040 m->is_readable ? 'r' : '-', m->is_executable ? 'x' : '-', m->name);
41 }
42 return os;
Brian Carlstrom27ec9612011-09-19 20:20:38 -070043}
44
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070045void CheckMapRequest(byte* addr, size_t byte_count) {
Brian Carlstrom27ec9612011-09-19 20:20:38 -070046 if (addr == NULL) {
47 return;
48 }
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070049
Elliott Hughes96970cd2012-03-13 15:46:31 -070050 uint32_t base = reinterpret_cast<size_t>(addr);
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070051 uint32_t limit = base + byte_count;
Brian Carlstrom27ec9612011-09-19 20:20:38 -070052
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070053 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
Elliott Hughes7bda1582012-06-07 11:00:54 -070058 << 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)
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070061 << map_info_list;
Elliott Hughes96970cd2012-03-13 15:46:31 -070062 }
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070063 free_map_info_list(map_info_list);
Brian Carlstrom27ec9612011-09-19 20:20:38 -070064}
65
Elliott Hughes96970cd2012-03-13 15:46:31 -070066#else
Elliott Hughes1bac54f2012-03-16 12:48:31 -070067static void CheckMapRequest(byte*, size_t) { }
Elliott Hughes96970cd2012-03-13 15:46:31 -070068#endif
69
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070070MemMap* MemMap::MapAnonymous(const char* name, byte* addr, size_t byte_count, int prot) {
71 CHECK_NE(0U, byte_count);
Brian Carlstrom27ec9612011-09-19 20:20:38 -070072 CHECK_NE(0, prot);
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070073 size_t page_aligned_byte_count = RoundUp(byte_count, kPageSize);
74 CheckMapRequest(addr, page_aligned_byte_count);
Elliott Hughes6c9c06d2011-11-07 16:43:47 -080075
76#ifdef USE_ASHMEM
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070077 ScopedFd fd(ashmem_create_region(name, page_aligned_byte_count));
Elliott Hughes6c9c06d2011-11-07 16:43:47 -080078 int flags = MAP_PRIVATE;
79 if (fd.get() == -1) {
80 PLOG(ERROR) << "ashmem_create_region failed (" << name << ")";
81 return NULL;
82 }
83#else
84 ScopedFd fd(-1);
85 int flags = MAP_PRIVATE | MAP_ANONYMOUS;
86#endif
87
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070088 byte* actual = reinterpret_cast<byte*>(mmap(addr, page_aligned_byte_count, prot, flags, fd.get(), 0));
Brian Carlstrom27ec9612011-09-19 20:20:38 -070089 if (actual == MAP_FAILED) {
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070090 PLOG(ERROR) << "mmap(" << reinterpret_cast<void*>(addr) << ", " << page_aligned_byte_count
Elliott Hughes5ea8d4b2012-05-30 15:21:36 -070091 << ", " << prot << ", " << flags << ", " << fd.get() << ", 0) failed for " << name;
Brian Carlstrom27ec9612011-09-19 20:20:38 -070092 return NULL;
93 }
Ian Rogers1c849e52012-06-28 14:00:33 -070094 return new MemMap(actual, byte_count, actual, page_aligned_byte_count, prot);
Brian Carlstrom27ec9612011-09-19 20:20:38 -070095}
96
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070097MemMap* MemMap::MapFileAtAddress(byte* addr, size_t byte_count, int prot, int flags, int fd, off_t start) {
98 CHECK_NE(0U, byte_count);
Brian Carlstrom27ec9612011-09-19 20:20:38 -070099 CHECK_NE(0, prot);
100 CHECK_NE(0, flags & (MAP_SHARED | MAP_PRIVATE));
Elliott Hughesecd3a6f2012-06-06 18:16:37 -0700101 // Adjust 'offset' and 'byte_count' to be page-aligned.
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700102 int page_offset = start % kPageSize;
103 off_t page_aligned_offset = start - page_offset;
Elliott Hughesecd3a6f2012-06-06 18:16:37 -0700104 size_t page_aligned_byte_count = RoundUp(byte_count + page_offset, kPageSize);
105 CheckMapRequest(addr, page_aligned_byte_count);
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700106 byte* actual = reinterpret_cast<byte*>(mmap(addr,
Elliott Hughesecd3a6f2012-06-06 18:16:37 -0700107 page_aligned_byte_count,
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700108 prot,
109 flags,
110 fd,
111 page_aligned_offset));
112 if (actual == MAP_FAILED) {
113 PLOG(ERROR) << "mmap failed";
114 return NULL;
115 }
Ian Rogers1c849e52012-06-28 14:00:33 -0700116 return new MemMap(actual + page_offset, byte_count, actual, page_aligned_byte_count, prot);
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700117}
118
119MemMap::~MemMap() {
Ian Rogers30fab402012-01-23 15:43:46 -0800120 if (base_begin_ == NULL && base_size_ == 0) {
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700121 return;
122 }
Ian Rogers30fab402012-01-23 15:43:46 -0800123 int result = munmap(base_begin_, base_size_);
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700124 if (result == -1) {
125 PLOG(FATAL) << "munmap failed";
126 }
127}
128
Ian Rogers1c849e52012-06-28 14:00:33 -0700129MemMap::MemMap(byte* begin, size_t size, void* base_begin, size_t base_size, int prot)
130 : begin_(begin), size_(size), base_begin_(base_begin), base_size_(base_size), prot_(prot) {
Ian Rogers30fab402012-01-23 15:43:46 -0800131 CHECK(begin_ != NULL);
132 CHECK_NE(size_, 0U);
133 CHECK(base_begin_ != NULL);
134 CHECK_NE(base_size_, 0U);
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700135};
136
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700137void MemMap::UnMapAtEnd(byte* new_end) {
138 DCHECK_GE(new_end, Begin());
139 DCHECK_LE(new_end, End());
140 size_t unmap_size = End() - new_end;
141 munmap(new_end, unmap_size);
142 size_ -= unmap_size;
143}
Logan Chiend88fa262012-06-06 15:23:32 +0800144
145bool MemMap::Protect(int prot) {
146 if (base_begin_ == NULL && base_size_ == 0) {
Ian Rogers1c849e52012-06-28 14:00:33 -0700147 prot_ = prot;
Logan Chiend88fa262012-06-06 15:23:32 +0800148 return true;
149 }
150
151 if (mprotect(base_begin_, base_size_, prot) == 0) {
Ian Rogers1c849e52012-06-28 14:00:33 -0700152 prot_ = prot;
Logan Chiend88fa262012-06-06 15:23:32 +0800153 return true;
154 }
155
Shih-wei Liaoa060ed92012-06-07 09:25:28 -0700156 PLOG(ERROR) << "mprotect(" << reinterpret_cast<void*>(base_begin_) << ", " << base_size_ << ", "
157 << prot << ") failed";
Logan Chiend88fa262012-06-06 15:23:32 +0800158 return false;
159}
160
Brian Carlstrom27ec9612011-09-19 20:20:38 -0700161} // namespace art