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#ifndef ART_RUNTIME_MEM_MAP_H_
18#define ART_RUNTIME_MEM_MAP_H_
19
20#include <stddef.h>
21#include <sys/types.h>
22
23#include <map>
24#include <mutex>
25#include <string>
26
27#include "android-base/thread_annotations.h"
28
29namespace art {
30
31#if defined(__LP64__) && (defined(__aarch64__) || defined(__mips__) || defined(__APPLE__))
32#define USE_ART_LOW_4G_ALLOCATOR 1
33#else
34#if defined(__LP64__) && !defined(__x86_64__)
35#error "Unrecognized 64-bit architecture."
36#endif
37#define USE_ART_LOW_4G_ALLOCATOR 0
38#endif
39
40#ifdef __linux__
41static constexpr bool kMadviseZeroes = true;
42#define HAVE_MREMAP_SYSCALL true
43#else
44static constexpr bool kMadviseZeroes = false;
45// We cannot ever perform MemMap::ReplaceWith on non-linux hosts since the syscall is not
46// present.
47#define HAVE_MREMAP_SYSCALL false
48#endif
49
50// Used to keep track of mmap segments.
51//
52// On 64b systems not supporting MAP_32BIT, the implementation of MemMap will do a linear scan
53// for free pages. For security, the start of this scan should be randomized. This requires a
54// dynamic initializer.
55// For this to work, it is paramount that there are no other static initializers that access MemMap.
56// Otherwise, calls might see uninitialized values.
57class MemMap {
58 public:
59  static constexpr bool kCanReplaceMapping = HAVE_MREMAP_SYSCALL;
60
61  // Replace the data in this memmmap with the data in the memmap pointed to by source. The caller
62  // relinquishes ownership of the source mmap.
63  //
64  // For the call to be successful:
65  //   * The range [dest->Begin, dest->Begin() + source->Size()] must not overlap with
66  //     [source->Begin(), source->End()].
67  //   * Neither source nor dest may be 'reused' mappings (they must own all the pages associated
68  //     with them.
69  //   * kCanReplaceMapping must be true.
70  //   * Neither source nor dest may use manual redzones.
71  //   * Both source and dest must have the same offset from the nearest page boundary.
72  //   * mremap must succeed when called on the mappings.
73  //
74  // If this call succeeds it will return true and:
75  //   * Deallocate *source
76  //   * Sets *source to nullptr
77  //   * The protection of this will remain the same.
78  //   * The size of this will be the size of the source
79  //   * The data in this will be the data from source.
80  //
81  // If this call fails it will return false and make no changes to *source or this. The ownership
82  // of the source mmap is returned to the caller.
83  bool ReplaceWith(/*in-out*/MemMap** source, /*out*/std::string* error);
84
85  // Request an anonymous region of length 'byte_count' and a requested base address.
86  // Use null as the requested base address if you don't care.
87  // "reuse" allows re-mapping an address range from an existing mapping.
88  //
89  // The word "anonymous" in this context means "not backed by a file". The supplied
90  // 'name' will be used -- on systems that support it -- to give the mapping
91  // a name.
92  //
93  // On success, returns returns a MemMap instance.  On failure, returns null.
94  static MemMap* MapAnonymous(const char* name,
95                              uint8_t* addr,
96                              size_t byte_count,
97                              int prot,
98                              bool low_4gb,
99                              bool reuse,
100                              std::string* error_msg,
101                              bool use_ashmem = true);
102
103  // Create placeholder for a region allocated by direct call to mmap.
104  // This is useful when we do not have control over the code calling mmap,
105  // but when we still want to keep track of it in the list.
106  // The region is not considered to be owned and will not be unmmaped.
107  static MemMap* MapDummy(const char* name, uint8_t* addr, size_t byte_count);
108
109  // Map part of a file, taking care of non-page aligned offsets.  The
110  // "start" offset is absolute, not relative.
111  //
112  // On success, returns returns a MemMap instance.  On failure, returns null.
113  static MemMap* MapFile(size_t byte_count,
114                         int prot,
115                         int flags,
116                         int fd,
117                         off_t start,
118                         bool low_4gb,
119                         const char* filename,
120                         std::string* error_msg) {
121    return MapFileAtAddress(nullptr,
122                            byte_count,
123                            prot,
124                            flags,
125                            fd,
126                            start,
127                            /*low_4gb*/low_4gb,
128                            /*reuse*/false,
129                            filename,
130                            error_msg);
131  }
132
133  // Map part of a file, taking care of non-page aligned offsets.  The "start" offset is absolute,
134  // not relative. This version allows requesting a specific address for the base of the mapping.
135  // "reuse" allows us to create a view into an existing mapping where we do not take ownership of
136  // the memory. If error_msg is null then we do not print /proc/maps to the log if
137  // MapFileAtAddress fails. This helps improve performance of the fail case since reading and
138  // printing /proc/maps takes several milliseconds in the worst case.
139  //
140  // On success, returns returns a MemMap instance.  On failure, returns null.
141  static MemMap* MapFileAtAddress(uint8_t* addr,
142                                  size_t byte_count,
143                                  int prot,
144                                  int flags,
145                                  int fd,
146                                  off_t start,
147                                  bool low_4gb,
148                                  bool reuse,
149                                  const char* filename,
150                                  std::string* error_msg);
151
152  // Releases the memory mapping.
153  ~MemMap() REQUIRES(!MemMap::mem_maps_lock_);
154
155  const std::string& GetName() const {
156    return name_;
157  }
158
159  bool Sync();
160
161  bool Protect(int prot);
162
163  void MadviseDontNeedAndZero();
164
165  int GetProtect() const {
166    return prot_;
167  }
168
169  uint8_t* Begin() const {
170    return begin_;
171  }
172
173  size_t Size() const {
174    return size_;
175  }
176
177  // Resize the mem-map by unmapping pages at the end. Currently only supports shrinking.
178  void SetSize(size_t new_size);
179
180  uint8_t* End() const {
181    return Begin() + Size();
182  }
183
184  void* BaseBegin() const {
185    return base_begin_;
186  }
187
188  size_t BaseSize() const {
189    return base_size_;
190  }
191
192  void* BaseEnd() const {
193    return reinterpret_cast<uint8_t*>(BaseBegin()) + BaseSize();
194  }
195
196  bool HasAddress(const void* addr) const {
197    return Begin() <= addr && addr < End();
198  }
199
200  // Unmap the pages at end and remap them to create another memory map.
201  MemMap* RemapAtEnd(uint8_t* new_end,
202                     const char* tail_name,
203                     int tail_prot,
204                     std::string* error_msg,
205                     bool use_ashmem = true);
206
207  static bool CheckNoGaps(MemMap* begin_map, MemMap* end_map)
208      REQUIRES(!MemMap::mem_maps_lock_);
209  static void DumpMaps(std::ostream& os, bool terse = false)
210      REQUIRES(!MemMap::mem_maps_lock_);
211
212  // Init and Shutdown are NOT thread safe.
213  // Both may be called multiple times and MemMap objects may be created any
214  // time after the first call to Init and before the first call to Shutodwn.
215  static void Init() REQUIRES(!MemMap::mem_maps_lock_);
216  static void Shutdown() REQUIRES(!MemMap::mem_maps_lock_);
217
218  // If the map is PROT_READ, try to read each page of the map to check it is in fact readable (not
219  // faulting). This is used to diagnose a bug b/19894268 where mprotect doesn't seem to be working
220  // intermittently.
221  void TryReadable();
222
223  // Align the map by unmapping the unaligned parts at the lower and the higher ends.
224  void AlignBy(size_t size);
225
226  // For annotation reasons.
227  static std::mutex* GetMemMapsLock() RETURN_CAPABILITY(mem_maps_lock_) {
228    return nullptr;
229  }
230
231 private:
232  MemMap(const std::string& name,
233         uint8_t* begin,
234         size_t size,
235         void* base_begin,
236         size_t base_size,
237         int prot,
238         bool reuse,
239         size_t redzone_size = 0) REQUIRES(!MemMap::mem_maps_lock_);
240
241  static void DumpMapsLocked(std::ostream& os, bool terse)
242      REQUIRES(MemMap::mem_maps_lock_);
243  static bool HasMemMap(MemMap* map)
244      REQUIRES(MemMap::mem_maps_lock_);
245  static MemMap* GetLargestMemMapAt(void* address)
246      REQUIRES(MemMap::mem_maps_lock_);
247  static bool ContainedWithinExistingMap(uint8_t* ptr, size_t size, std::string* error_msg)
248      REQUIRES(!MemMap::mem_maps_lock_);
249
250  // Internal version of mmap that supports low 4gb emulation.
251  static void* MapInternal(void* addr,
252                           size_t length,
253                           int prot,
254                           int flags,
255                           int fd,
256                           off_t offset,
257                           bool low_4gb)
258      REQUIRES(!MemMap::mem_maps_lock_);
259  static void* MapInternalArtLow4GBAllocator(size_t length,
260                                             int prot,
261                                             int flags,
262                                             int fd,
263                                             off_t offset)
264      REQUIRES(!MemMap::mem_maps_lock_);
265
266  const std::string name_;
267  uint8_t* begin_;  // Start of data. May be changed by AlignBy.
268  size_t size_;  // Length of data.
269
270  void* base_begin_;  // Page-aligned base address. May be changed by AlignBy.
271  size_t base_size_;  // Length of mapping. May be changed by RemapAtEnd (ie Zygote).
272  int prot_;  // Protection of the map.
273
274  // When reuse_ is true, this is just a view of an existing mapping
275  // and we do not take ownership and are not responsible for
276  // unmapping.
277  const bool reuse_;
278
279  // When already_unmapped_ is true the destructor will not call munmap.
280  bool already_unmapped_;
281
282  const size_t redzone_size_;
283
284#if USE_ART_LOW_4G_ALLOCATOR
285  static uintptr_t next_mem_pos_;   // Next memory location to check for low_4g extent.
286#endif
287
288  static std::mutex* mem_maps_lock_;
289
290  friend class MemMapTest;  // To allow access to base_begin_ and base_size_.
291};
292
293std::ostream& operator<<(std::ostream& os, const MemMap& mem_map);
294
295// Zero and release pages if possible, no requirements on alignments.
296void ZeroAndReleasePages(void* address, size_t length);
297
298}  // namespace art
299
300#endif  // ART_RUNTIME_MEM_MAP_H_
301