blob: 196a7f6292420e0904f859b51260ed8b0948dad2 [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.
Mathieu Chartier2cebb242015-04-21 16:50:40 -070056 // Use null as the requested base address if you don't care.
Vladimir Marko5c42c292015-02-25 12:02:49 +000057 // "reuse" allows re-mapping an address range from an existing mapping.
Elliott Hughes6c9c06d2011-11-07 16:43:47 -080058 //
59 // The word "anonymous" in this context means "not backed by a file". The supplied
60 // 'ashmem_name' will be used -- on systems that support it -- to give the mapping
61 // a name.
Brian Carlstrom4a289ed2011-08-16 17:17:49 -070062 //
Mathieu Chartier2cebb242015-04-21 16:50:40 -070063 // On success, returns returns a MemMap instance. On failure, returns null.
Ian Rogers13735952014-10-08 12:43:28 -070064 static MemMap* MapAnonymous(const char* ashmem_name, uint8_t* addr, size_t byte_count, int prot,
Vladimir Marko5c42c292015-02-25 12:02:49 +000065 bool low_4gb, bool reuse, std::string* error_msg);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070066
David Srbecky1baabf02015-06-16 17:12:34 +000067 // Create placeholder for a region allocated by direct call to mmap.
68 // This is useful when we do not have control over the code calling mmap,
69 // but when we still want to keep track of it in the list.
70 // The region is not considered to be owned and will not be unmmaped.
71 static MemMap* MapDummy(const char* name, uint8_t* addr, size_t byte_count);
72
Brian Carlstromdb4d5402011-08-09 12:18:28 -070073 // Map part of a file, taking care of non-page aligned offsets. The
74 // "start" offset is absolute, not relative.
75 //
Mathieu Chartier2cebb242015-04-21 16:50:40 -070076 // On success, returns returns a MemMap instance. On failure, returns null.
Ian Rogers8d31bbd2013-10-13 10:44:14 -070077 static MemMap* MapFile(size_t byte_count, int prot, int flags, int fd, off_t start,
78 const char* filename, std::string* error_msg) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -070079 return MapFileAtAddress(
80 nullptr, byte_count, prot, flags, fd, start, false, filename, error_msg);
Brian Carlstrom4a289ed2011-08-16 17:17:49 -070081 }
82
83 // Map part of a file, taking care of non-page aligned offsets. The
84 // "start" offset is absolute, not relative. This version allows
Jim_Guoa62a5882014-04-28 11:11:57 +080085 // requesting a specific address for the base of the
86 // mapping. "reuse" allows us to create a view into an existing
87 // mapping where we do not take ownership of the memory.
Brian Carlstrom4a289ed2011-08-16 17:17:49 -070088 //
Mathieu Chartier2cebb242015-04-21 16:50:40 -070089 // On success, returns returns a MemMap instance. On failure, returns null.
Ian Rogers13735952014-10-08 12:43:28 -070090 static MemMap* MapFileAtAddress(uint8_t* addr, size_t byte_count, int prot, int flags, int fd,
Ian Rogers8d31bbd2013-10-13 10:44:14 -070091 off_t start, bool reuse, const char* filename,
92 std::string* error_msg);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070093
Mathieu Chartier2cebb242015-04-21 16:50:40 -070094 // Releases the memory mapping.
Mathieu Chartier90443472015-07-16 20:32:27 -070095 ~MemMap() REQUIRES(!Locks::mem_maps_lock_);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070096
Brian Carlstrom0d6adac2014-02-05 17:39:16 -080097 const std::string& GetName() const {
98 return name_;
99 }
100
Logan Chiend88fa262012-06-06 15:23:32 +0800101 bool Protect(int prot);
102
Ian Rogersc5f17732014-06-05 20:48:42 -0700103 void MadviseDontNeedAndZero();
104
Ian Rogers1c849e52012-06-28 14:00:33 -0700105 int GetProtect() const {
106 return prot_;
107 }
108
Ian Rogers13735952014-10-08 12:43:28 -0700109 uint8_t* Begin() const {
Ian Rogers30fab402012-01-23 15:43:46 -0800110 return begin_;
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700111 }
112
Ian Rogers30fab402012-01-23 15:43:46 -0800113 size_t Size() const {
114 return size_;
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700115 }
116
Mathieu Chartier379d09f2015-01-08 11:28:13 -0800117 // Resize the mem-map by unmapping pages at the end. Currently only supports shrinking.
118 void SetSize(size_t new_size);
119
Ian Rogers13735952014-10-08 12:43:28 -0700120 uint8_t* End() const {
Mathieu Chartier2fde5332012-09-14 14:51:54 -0700121 return Begin() + Size();
122 }
123
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800124 void* BaseBegin() const {
125 return base_begin_;
126 }
127
128 size_t BaseSize() const {
129 return base_size_;
130 }
131
132 void* BaseEnd() const {
Ian Rogers13735952014-10-08 12:43:28 -0700133 return reinterpret_cast<uint8_t*>(BaseBegin()) + BaseSize();
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800134 }
135
Mathieu Chartier2fde5332012-09-14 14:51:54 -0700136 bool HasAddress(const void* addr) const {
137 return Begin() <= addr && addr < End();
Brian Carlstromb765be02011-08-17 23:54:10 -0700138 }
139
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700140 // Unmap the pages at end and remap them to create another memory map.
Ian Rogers13735952014-10-08 12:43:28 -0700141 MemMap* RemapAtEnd(uint8_t* new_end, const char* tail_name, int tail_prot,
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700142 std::string* error_msg);
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700143
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700144 static bool CheckNoGaps(MemMap* begin_map, MemMap* end_map)
Mathieu Chartier90443472015-07-16 20:32:27 -0700145 REQUIRES(!Locks::mem_maps_lock_);
Vladimir Marko17a924a2015-05-08 15:17:32 +0100146 static void DumpMaps(std::ostream& os, bool terse = false)
Mathieu Chartier90443472015-07-16 20:32:27 -0700147 REQUIRES(!Locks::mem_maps_lock_);
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700148
Mathieu Chartierbad02672014-08-25 13:08:22 -0700149 typedef AllocationTrackingMultiMap<void*, MemMap*, kAllocatorTagMaps> Maps;
150
Mathieu Chartier90443472015-07-16 20:32:27 -0700151 static void Init() REQUIRES(!Locks::mem_maps_lock_);
152 static void Shutdown() REQUIRES(!Locks::mem_maps_lock_);
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700153
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700154 private:
Ian Rogers13735952014-10-08 12:43:28 -0700155 MemMap(const std::string& name, uint8_t* begin, size_t size, void* base_begin, size_t base_size,
Mathieu Chartier90443472015-07-16 20:32:27 -0700156 int prot, bool reuse, size_t redzone_size = 0) REQUIRES(!Locks::mem_maps_lock_);
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700157
Vladimir Marko17a924a2015-05-08 15:17:32 +0100158 static void DumpMapsLocked(std::ostream& os, bool terse)
Mathieu Chartier90443472015-07-16 20:32:27 -0700159 REQUIRES(Locks::mem_maps_lock_);
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700160 static bool HasMemMap(MemMap* map)
Mathieu Chartier90443472015-07-16 20:32:27 -0700161 REQUIRES(Locks::mem_maps_lock_);
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700162 static MemMap* GetLargestMemMapAt(void* address)
Mathieu Chartier90443472015-07-16 20:32:27 -0700163 REQUIRES(Locks::mem_maps_lock_);
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700164
Jim_Guoa62a5882014-04-28 11:11:57 +0800165 const std::string name_;
Ian Rogers13735952014-10-08 12:43:28 -0700166 uint8_t* const begin_; // Start of data.
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700167 size_t size_; // Length of data.
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700168
Ian Rogers1c849e52012-06-28 14:00:33 -0700169 void* const base_begin_; // Page-aligned base address.
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700170 size_t base_size_; // Length of mapping. May be changed by RemapAtEnd (ie Zygote).
Ian Rogers1c849e52012-06-28 14:00:33 -0700171 int prot_; // Protection of the map.
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700172
Jim_Guoa62a5882014-04-28 11:11:57 +0800173 // When reuse_ is true, this is just a view of an existing mapping
174 // and we do not take ownership and are not responsible for
175 // unmapping.
176 const bool reuse_;
177
Evgenii Stepanov1e133742015-05-20 12:30:59 -0700178 const size_t redzone_size_;
179
Ian Rogersc3ccc102014-06-25 11:52:14 -0700180#if USE_ART_LOW_4G_ALLOCATOR
181 static uintptr_t next_mem_pos_; // Next memory location to check for low_4g extent.
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000182#endif
183
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700184 // 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 -0700185 static Maps* maps_ GUARDED_BY(Locks::mem_maps_lock_);
Hiroshi Yamauchi3eed93d2014-06-04 11:43:59 -0700186
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700187 friend class MemMapTest; // To allow access to base_begin_ and base_size_.
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700188};
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800189std::ostream& operator<<(std::ostream& os, const MemMap& mem_map);
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800190std::ostream& operator<<(std::ostream& os, const MemMap::Maps& mem_maps);
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700191
192} // namespace art
193
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700194#endif // ART_RUNTIME_MEM_MAP_H_