blob: 9b003aa66cec836d808b0ea81c3b8ac0bb68406c [file] [log] [blame]
Brian Carlstromdb4d5402011-08-09 12:18:28 -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
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_MEM_MAP_H_
18#define ART_RUNTIME_MEM_MAP_H_
Brian Carlstromdb4d5402011-08-09 12:18:28 -070019
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -070020#include "base/mutex.h"
21
Mathieu Chartier1c23e1e2012-10-12 14:14:11 -070022#include <string>
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -070023#include <map>
Mathieu Chartier1c23e1e2012-10-12 14:14:11 -070024
Brian Carlstrom27ec9612011-09-19 20:20:38 -070025#include <stddef.h>
Elliott Hughesa168c832012-06-12 15:34:20 -070026#include <sys/mman.h> // For the PROT_* and MAP_* constants.
Brian Carlstrom27ec9612011-09-19 20:20:38 -070027#include <sys/types.h>
Brian Carlstromdb4d5402011-08-09 12:18:28 -070028
Mathieu Chartierbad02672014-08-25 13:08:22 -070029#include "base/allocator.h"
Brian Carlstrom27ec9612011-09-19 20:20:38 -070030#include "globals.h"
Brian Carlstromdb4d5402011-08-09 12:18:28 -070031
32namespace art {
33
Ian Rogersc3ccc102014-06-25 11:52:14 -070034#if defined(__LP64__) && (!defined(__x86_64__) || defined(__APPLE__))
35#define USE_ART_LOW_4G_ALLOCATOR 1
36#else
37#define USE_ART_LOW_4G_ALLOCATOR 0
38#endif
39
Ian Rogersc5f17732014-06-05 20:48:42 -070040#ifdef __linux__
41static constexpr bool kMadviseZeroes = true;
42#else
43static constexpr bool kMadviseZeroes = false;
44#endif
45
Brian Carlstromdb4d5402011-08-09 12:18:28 -070046// Used to keep track of mmap segments.
Andreas Gamped8f26db2014-05-19 17:01:13 -070047//
48// On 64b systems not supporting MAP_32BIT, the implementation of MemMap will do a linear scan
49// for free pages. For security, the start of this scan should be randomized. This requires a
50// dynamic initializer.
51// For this to work, it is paramount that there are no other static initializers that access MemMap.
52// Otherwise, calls might see uninitialized values.
Brian Carlstromdb4d5402011-08-09 12:18:28 -070053class MemMap {
54 public:
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070055 // Request an anonymous region of length 'byte_count' and a requested base address.
Elliott Hughes6c9c06d2011-11-07 16:43:47 -080056 // Use NULL as the requested base address if you don't care.
57 //
58 // The word "anonymous" in this context means "not backed by a file". The supplied
59 // 'ashmem_name' will be used -- on systems that support it -- to give the mapping
60 // a name.
Brian Carlstrom4a289ed2011-08-16 17:17:49 -070061 //
62 // On success, returns returns a MemMap instance. On failure, returns a NULL;
Ian Rogers13735952014-10-08 12:43:28 -070063 static MemMap* MapAnonymous(const char* ashmem_name, uint8_t* addr, size_t byte_count, int prot,
Ian Rogersef7d42f2014-01-06 12:55:46 -080064 bool low_4gb, std::string* error_msg);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070065
66 // Map part of a file, taking care of non-page aligned offsets. The
67 // "start" offset is absolute, not relative.
68 //
69 // On success, returns returns a MemMap instance. On failure, returns a NULL;
Ian Rogers8d31bbd2013-10-13 10:44:14 -070070 static MemMap* MapFile(size_t byte_count, int prot, int flags, int fd, off_t start,
71 const char* filename, std::string* error_msg) {
72 return MapFileAtAddress(NULL, byte_count, prot, flags, fd, start, false, filename, error_msg);
Brian Carlstrom4a289ed2011-08-16 17:17:49 -070073 }
74
75 // Map part of a file, taking care of non-page aligned offsets. The
76 // "start" offset is absolute, not relative. This version allows
Jim_Guoa62a5882014-04-28 11:11:57 +080077 // requesting a specific address for the base of the
78 // mapping. "reuse" allows us to create a view into an existing
79 // mapping where we do not take ownership of the memory.
Brian Carlstrom4a289ed2011-08-16 17:17:49 -070080 //
Narayan Kamathb89c3da2014-08-21 17:38:09 +010081 // On success, returns returns a MemMap instance. On failure, returns a
82 // nullptr;
Ian Rogers13735952014-10-08 12:43:28 -070083 static MemMap* MapFileAtAddress(uint8_t* addr, size_t byte_count, int prot, int flags, int fd,
Ian Rogers8d31bbd2013-10-13 10:44:14 -070084 off_t start, bool reuse, const char* filename,
85 std::string* error_msg);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070086
Brian Carlstrom27ec9612011-09-19 20:20:38 -070087 // Releases the memory mapping
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -070088 ~MemMap() LOCKS_EXCLUDED(Locks::mem_maps_lock_);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070089
Brian Carlstrom0d6adac2014-02-05 17:39:16 -080090 const std::string& GetName() const {
91 return name_;
92 }
93
Logan Chiend88fa262012-06-06 15:23:32 +080094 bool Protect(int prot);
95
Ian Rogersc5f17732014-06-05 20:48:42 -070096 void MadviseDontNeedAndZero();
97
Ian Rogers1c849e52012-06-28 14:00:33 -070098 int GetProtect() const {
99 return prot_;
100 }
101
Ian Rogers13735952014-10-08 12:43:28 -0700102 uint8_t* Begin() const {
Ian Rogers30fab402012-01-23 15:43:46 -0800103 return begin_;
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700104 }
105
Ian Rogers30fab402012-01-23 15:43:46 -0800106 size_t Size() const {
107 return size_;
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700108 }
109
Ian Rogers13735952014-10-08 12:43:28 -0700110 uint8_t* End() const {
Mathieu Chartier2fde5332012-09-14 14:51:54 -0700111 return Begin() + Size();
112 }
113
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800114 void* BaseBegin() const {
115 return base_begin_;
116 }
117
118 size_t BaseSize() const {
119 return base_size_;
120 }
121
122 void* BaseEnd() const {
Ian Rogers13735952014-10-08 12:43:28 -0700123 return reinterpret_cast<uint8_t*>(BaseBegin()) + BaseSize();
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800124 }
125
Mathieu Chartier2fde5332012-09-14 14:51:54 -0700126 bool HasAddress(const void* addr) const {
127 return Begin() <= addr && addr < End();
Brian Carlstromb765be02011-08-17 23:54:10 -0700128 }
129
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700130 // Unmap the pages at end and remap them to create another memory map.
Ian Rogers13735952014-10-08 12:43:28 -0700131 MemMap* RemapAtEnd(uint8_t* new_end, const char* tail_name, int tail_prot,
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700132 std::string* error_msg);
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700133
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700134 static bool CheckNoGaps(MemMap* begin_map, MemMap* end_map)
135 LOCKS_EXCLUDED(Locks::mem_maps_lock_);
136 static void DumpMaps(std::ostream& os)
137 LOCKS_EXCLUDED(Locks::mem_maps_lock_);
138
Mathieu Chartierbad02672014-08-25 13:08:22 -0700139 typedef AllocationTrackingMultiMap<void*, MemMap*, kAllocatorTagMaps> Maps;
140
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700141 static void Init() LOCKS_EXCLUDED(Locks::mem_maps_lock_);
142 static void Shutdown() LOCKS_EXCLUDED(Locks::mem_maps_lock_);
143
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700144 private:
Ian Rogers13735952014-10-08 12:43:28 -0700145 MemMap(const std::string& name, uint8_t* begin, size_t size, void* base_begin, size_t base_size,
Jim_Guoa62a5882014-04-28 11:11:57 +0800146 int prot, bool reuse) LOCKS_EXCLUDED(Locks::mem_maps_lock_);
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700147
Mathieu Chartierbad02672014-08-25 13:08:22 -0700148 static void DumpMapsLocked(std::ostream& os)
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700149 EXCLUSIVE_LOCKS_REQUIRED(Locks::mem_maps_lock_);
150 static bool HasMemMap(MemMap* map)
151 EXCLUSIVE_LOCKS_REQUIRED(Locks::mem_maps_lock_);
152 static MemMap* GetLargestMemMapAt(void* address)
153 EXCLUSIVE_LOCKS_REQUIRED(Locks::mem_maps_lock_);
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700154
Jim_Guoa62a5882014-04-28 11:11:57 +0800155 const std::string name_;
Ian Rogers13735952014-10-08 12:43:28 -0700156 uint8_t* const begin_; // Start of data.
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700157 size_t size_; // Length of data.
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700158
Ian Rogers1c849e52012-06-28 14:00:33 -0700159 void* const base_begin_; // Page-aligned base address.
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700160 size_t base_size_; // Length of mapping. May be changed by RemapAtEnd (ie Zygote).
Ian Rogers1c849e52012-06-28 14:00:33 -0700161 int prot_; // Protection of the map.
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700162
Jim_Guoa62a5882014-04-28 11:11:57 +0800163 // When reuse_ is true, this is just a view of an existing mapping
164 // and we do not take ownership and are not responsible for
165 // unmapping.
166 const bool reuse_;
167
Ian Rogersc3ccc102014-06-25 11:52:14 -0700168#if USE_ART_LOW_4G_ALLOCATOR
169 static uintptr_t next_mem_pos_; // Next memory location to check for low_4g extent.
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000170#endif
171
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700172 // All the non-empty MemMaps. Use a multimap as we do a reserve-and-divide (eg ElfMap::Load()).
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700173 static Maps* maps_ GUARDED_BY(Locks::mem_maps_lock_);
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700174
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700175 friend class MemMapTest; // To allow access to base_begin_ and base_size_.
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700176};
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800177std::ostream& operator<<(std::ostream& os, const MemMap& mem_map);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800178std::ostream& operator<<(std::ostream& os, const MemMap::Maps& mem_maps);
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700179
180} // namespace art
181
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700182#endif // ART_RUNTIME_MEM_MAP_H_