mem_map.h revision d8f26dbebe72c1cbdfa85bdeeb003283c7435db3 
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 <string>
21
22#include <stddef.h>
23#include <sys/mman.h>  // For the PROT_* and MAP_* constants.
24#include <sys/types.h>
25
26#include "globals.h"
27
28namespace art {
29
30// Used to keep track of mmap segments.
31//
32// On 64b systems not supporting MAP_32BIT, the implementation of MemMap will do a linear scan
33// for free pages. For security, the start of this scan should be randomized. This requires a
34// dynamic initializer.
35// For this to work, it is paramount that there are no other static initializers that access MemMap.
36// Otherwise, calls might see uninitialized values.
37class MemMap {
38 public:
39  // Request an anonymous region of length 'byte_count' and a requested base address.
40  // Use NULL as the requested base address if you don't care.
41  //
42  // The word "anonymous" in this context means "not backed by a file". The supplied
43  // 'ashmem_name' will be used -- on systems that support it -- to give the mapping
44  // a name.
45  //
46  // On success, returns returns a MemMap instance.  On failure, returns a NULL;
47  static MemMap* MapAnonymous(const char* ashmem_name, byte* addr, size_t byte_count, int prot,
48                              bool low_4gb, std::string* error_msg);
49
50  // Map part of a file, taking care of non-page aligned offsets.  The
51  // "start" offset is absolute, not relative.
52  //
53  // On success, returns returns a MemMap instance.  On failure, returns a NULL;
54  static MemMap* MapFile(size_t byte_count, int prot, int flags, int fd, off_t start,
55                         const char* filename, std::string* error_msg) {
56    return MapFileAtAddress(NULL, byte_count, prot, flags, fd, start, false, filename, error_msg);
57  }
58
59  // Map part of a file, taking care of non-page aligned offsets.  The
60  // "start" offset is absolute, not relative. This version allows
61  // requesting a specific address for the base of the mapping.
62  //
63  // On success, returns returns a MemMap instance.  On failure, returns a NULL;
64  static MemMap* MapFileAtAddress(byte* addr, size_t byte_count, int prot, int flags, int fd,
65                                  off_t start, bool reuse, const char* filename,
66                                  std::string* error_msg);
67
68  // Releases the memory mapping
69  ~MemMap();
70
71  const std::string& GetName() const {
72    return name_;
73  }
74
75  bool Protect(int prot);
76
77  int GetProtect() const {
78    return prot_;
79  }
80
81  byte* Begin() const {
82    return begin_;
83  }
84
85  size_t Size() const {
86    return size_;
87  }
88
89  byte* End() const {
90    return Begin() + Size();
91  }
92
93  void* BaseBegin() const {
94    return base_begin_;
95  }
96
97  size_t BaseSize() const {
98    return base_size_;
99  }
100
101  void* BaseEnd() const {
102    return reinterpret_cast<byte*>(BaseBegin()) + BaseSize();
103  }
104
105  bool HasAddress(const void* addr) const {
106    return Begin() <= addr && addr < End();
107  }
108
109  // Unmap the pages at end and remap them to create another memory map.
110  MemMap* RemapAtEnd(byte* new_end, const char* tail_name, int tail_prot,
111                     std::string* error_msg);
112
113 private:
114  MemMap(const std::string& name, byte* begin, size_t size, void* base_begin, size_t base_size,
115         int prot);
116
117  std::string name_;
118  byte* const begin_;  // Start of data.
119  size_t size_;  // Length of data.
120
121  void* const base_begin_;  // Page-aligned base address.
122  size_t base_size_;  // Length of mapping. May be changed by RemapAtEnd (ie Zygote).
123  int prot_;  // Protection of the map.
124
125#if defined(__LP64__) && !defined(__x86_64__)
126  static uintptr_t next_mem_pos_;   // next memory location to check for low_4g extent
127#endif
128
129  friend class MemMapTest;  // To allow access to base_begin_ and base_size_.
130};
131std::ostream& operator<<(std::ostream& os, const MemMap& mem_map);
132
133}  // namespace art
134
135#endif  // ART_RUNTIME_MEM_MAP_H_
136