blob: 141185663b34c8a2e926aa176d366eba2376dfab [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
Mathieu Chartier1c23e1e2012-10-12 14:14:11 -070020#include <string>
21
Brian Carlstrom27ec9612011-09-19 20:20:38 -070022#include <stddef.h>
Elliott Hughesa168c832012-06-12 15:34:20 -070023#include <sys/mman.h> // For the PROT_* and MAP_* constants.
Brian Carlstrom27ec9612011-09-19 20:20:38 -070024#include <sys/types.h>
Brian Carlstromdb4d5402011-08-09 12:18:28 -070025
Brian Carlstrom27ec9612011-09-19 20:20:38 -070026#include "globals.h"
Brian Carlstromdb4d5402011-08-09 12:18:28 -070027
28namespace art {
29
30// Used to keep track of mmap segments.
Andreas Gamped8f26db2014-05-19 17:01:13 -070031//
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.
Brian Carlstromdb4d5402011-08-09 12:18:28 -070037class MemMap {
38 public:
Elliott Hughesecd3a6f2012-06-06 18:16:37 -070039 // Request an anonymous region of length 'byte_count' and a requested base address.
Elliott Hughes6c9c06d2011-11-07 16:43:47 -080040 // 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.
Brian Carlstrom4a289ed2011-08-16 17:17:49 -070045 //
46 // On success, returns returns a MemMap instance. On failure, returns a NULL;
Ian Rogers8d31bbd2013-10-13 10:44:14 -070047 static MemMap* MapAnonymous(const char* ashmem_name, byte* addr, size_t byte_count, int prot,
Ian Rogersef7d42f2014-01-06 12:55:46 -080048 bool low_4gb, std::string* error_msg);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070049
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;
Ian Rogers8d31bbd2013-10-13 10:44:14 -070054 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);
Brian Carlstrom4a289ed2011-08-16 17:17:49 -070057 }
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;
Ian Rogers8d31bbd2013-10-13 10:44:14 -070064 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);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070067
Brian Carlstrom27ec9612011-09-19 20:20:38 -070068 // Releases the memory mapping
69 ~MemMap();
Brian Carlstromdb4d5402011-08-09 12:18:28 -070070
Brian Carlstrom0d6adac2014-02-05 17:39:16 -080071 const std::string& GetName() const {
72 return name_;
73 }
74
Logan Chiend88fa262012-06-06 15:23:32 +080075 bool Protect(int prot);
76
Ian Rogers1c849e52012-06-28 14:00:33 -070077 int GetProtect() const {
78 return prot_;
79 }
80
Ian Rogers30fab402012-01-23 15:43:46 -080081 byte* Begin() const {
82 return begin_;
Brian Carlstromdb4d5402011-08-09 12:18:28 -070083 }
84
Ian Rogers30fab402012-01-23 15:43:46 -080085 size_t Size() const {
86 return size_;
Brian Carlstromdb4d5402011-08-09 12:18:28 -070087 }
88
Ian Rogers30fab402012-01-23 15:43:46 -080089 byte* End() const {
Mathieu Chartier2fde5332012-09-14 14:51:54 -070090 return Begin() + Size();
91 }
92
Brian Carlstrom0d6adac2014-02-05 17:39:16 -080093 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
Mathieu Chartier2fde5332012-09-14 14:51:54 -0700105 bool HasAddress(const void* addr) const {
106 return Begin() <= addr && addr < End();
Brian Carlstromb765be02011-08-17 23:54:10 -0700107 }
108
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700109 // 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);
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700112
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700113 private:
Mathieu Chartier1c23e1e2012-10-12 14:14:11 -0700114 MemMap(const std::string& name, byte* begin, size_t size, void* base_begin, size_t base_size,
115 int prot);
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700116
Mathieu Chartier1c23e1e2012-10-12 14:14:11 -0700117 std::string name_;
Ian Rogers1c849e52012-06-28 14:00:33 -0700118 byte* const begin_; // Start of data.
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700119 size_t size_; // Length of data.
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700120
Ian Rogers1c849e52012-06-28 14:00:33 -0700121 void* const base_begin_; // Page-aligned base address.
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700122 size_t base_size_; // Length of mapping. May be changed by RemapAtEnd (ie Zygote).
Ian Rogers1c849e52012-06-28 14:00:33 -0700123 int prot_; // Protection of the map.
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700124
Stuart Monteith8dba5aa2014-03-12 12:44:01 +0000125#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
Hiroshi Yamauchifd7e7f12013-10-22 14:17:48 -0700129 friend class MemMapTest; // To allow access to base_begin_ and base_size_.
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700130};
Brian Carlstrom0d6adac2014-02-05 17:39:16 -0800131std::ostream& operator<<(std::ostream& os, const MemMap& mem_map);
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700132
133} // namespace art
134
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700135#endif // ART_RUNTIME_MEM_MAP_H_