1 /*
2  * Copyright 2019 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_JIT_JIT_MEMORY_REGION_H_
18 #define ART_RUNTIME_JIT_JIT_MEMORY_REGION_H_
19 
20 #include <string>
21 
22 #include "arch/instruction_set.h"
23 #include "base/globals.h"
24 #include "base/locks.h"
25 #include "base/mem_map.h"
26 #include "gc_root-inl.h"
27 #include "handle.h"
28 
29 namespace art HIDDEN {
30 
31 namespace mirror {
32 class Object;
33 }
34 
35 namespace jit {
36 
37 class TestZygoteMemory;
38 
39 // Number of bytes represented by a bit in the CodeCacheBitmap. Value is reasonable for all
40 // architectures.
41 static constexpr int kJitCodeAccountingBytes = 16;
42 
43 // Helper to get the size required for emitting `number_of_roots` in the
44 // data portion of a JIT memory region.
ComputeRootTableSize(uint32_t number_of_roots)45 uint32_t inline ComputeRootTableSize(uint32_t number_of_roots) {
46   return sizeof(uint32_t) + number_of_roots * sizeof(GcRoot<mirror::Object>);
47 }
48 
49 // Represents a memory region for the JIT, where code and data are stored. This class
50 // provides allocation and deallocation primitives.
51 class JitMemoryRegion {
52  public:
JitMemoryRegion()53   JitMemoryRegion()
54       : initial_capacity_(0),
55         max_capacity_(0),
56         current_capacity_(0),
57         data_end_(0),
58         exec_end_(0),
59         used_memory_for_code_(0),
60         used_memory_for_data_(0),
61         data_pages_(),
62         writable_data_pages_(),
63         exec_pages_(),
64         non_exec_pages_(),
65         data_mspace_(nullptr),
66         exec_mspace_(nullptr) {}
67 
68   bool Initialize(size_t initial_capacity,
69                   size_t max_capacity,
70                   bool rwx_memory_allowed,
71                   bool is_zygote,
72                   std::string* error_msg)
73       REQUIRES(Locks::jit_lock_);
74 
75   // Try to increase the current capacity of the code cache. Return whether we
76   // succeeded at doing so.
77   bool IncreaseCodeCacheCapacity() REQUIRES(Locks::jit_lock_);
78 
79   // Set the footprint limit of the code cache.
80   void SetFootprintLimit(size_t new_footprint) REQUIRES(Locks::jit_lock_);
81 
82   const uint8_t* AllocateCode(size_t code_size) REQUIRES(Locks::jit_lock_);
83   void FreeCode(const uint8_t* code) REQUIRES(Locks::jit_lock_);
84   const uint8_t* AllocateData(size_t data_size) REQUIRES(Locks::jit_lock_);
85   void FreeData(const uint8_t* data) REQUIRES(Locks::jit_lock_);
86   void FreeData(uint8_t* writable_data) REQUIRES(Locks::jit_lock_) = delete;
87   void FreeWritableData(uint8_t* writable_data) REQUIRES(Locks::jit_lock_);
88 
89   // Emit header and code into the memory pointed by `reserved_code` (despite it being const).
90   // Returns pointer to copied code (within reserved_code region; after OatQuickMethodHeader).
91   const uint8_t* CommitCode(ArrayRef<const uint8_t> reserved_code,
92                             ArrayRef<const uint8_t> code,
93                             const uint8_t* stack_map)
94       REQUIRES(Locks::jit_lock_);
95 
96   // Emit roots and stack map into the memory pointed by `roots_data` (despite it being const).
97   bool CommitData(ArrayRef<const uint8_t> reserved_data,
98                   const std::vector<Handle<mirror::Object>>& roots,
99                   ArrayRef<const uint8_t> stack_map)
100       REQUIRES(Locks::jit_lock_)
101       REQUIRES_SHARED(Locks::mutator_lock_);
102 
ResetWritableMappings()103   void ResetWritableMappings() REQUIRES(Locks::jit_lock_) {
104     non_exec_pages_.ResetInForkedProcess();
105     writable_data_pages_.ResetInForkedProcess();
106     // Also clear the mspaces, which, in their implementation,
107     // point to the discarded mappings.
108     exec_mspace_ = nullptr;
109     data_mspace_ = nullptr;
110   }
111 
IsValid()112   bool IsValid() const NO_THREAD_SAFETY_ANALYSIS {
113     return exec_mspace_ != nullptr || data_mspace_ != nullptr;
114   }
115 
116   template <typename T>
FillData(const T * address,size_t n,const T & t)117   void FillData(const T* address, size_t n, const T& t)  REQUIRES(Locks::jit_lock_) {
118     std::fill_n(GetWritableDataAddress(address), n, t);
119   }
120 
121   // Generic helper for writing abritrary data in the data portion of the
122   // region.
123   template <typename T>
WriteData(const T * address,const T & value)124   void WriteData(const T* address, const T& value) {
125     *GetWritableDataAddress(address) = value;
126   }
127 
HasDualCodeMapping()128   bool HasDualCodeMapping() const {
129     return non_exec_pages_.IsValid();
130   }
131 
HasDualDataMapping()132   bool HasDualDataMapping() const {
133     return writable_data_pages_.IsValid();
134   }
135 
HasCodeMapping()136   bool HasCodeMapping() const {
137     return exec_pages_.IsValid();
138   }
139 
IsInDataSpace(const void * ptr)140   bool IsInDataSpace(const void* ptr) const {
141     return data_pages_.HasAddress(ptr);
142   }
143 
IsInExecSpace(const void * ptr)144   bool IsInExecSpace(const void* ptr) const {
145     return exec_pages_.HasAddress(ptr);
146   }
147 
GetExecPages()148   const MemMap* GetExecPages() const {
149     return &exec_pages_;
150   }
151 
152   void* MoreCore(const void* mspace, intptr_t increment);
153 
OwnsSpace(const void * mspace)154   bool OwnsSpace(const void* mspace) const NO_THREAD_SAFETY_ANALYSIS {
155     return mspace == data_mspace_ || mspace == exec_mspace_;
156   }
157 
GetCurrentCapacity()158   size_t GetCurrentCapacity() const REQUIRES(Locks::jit_lock_) {
159     return current_capacity_;
160   }
161 
GetMaxCapacity()162   size_t GetMaxCapacity() const REQUIRES(Locks::jit_lock_) {
163     return max_capacity_;
164   }
165 
GetUsedMemoryForCode()166   size_t GetUsedMemoryForCode() const REQUIRES(Locks::jit_lock_) {
167     return used_memory_for_code_;
168   }
169 
GetResidentMemoryForCode()170   size_t GetResidentMemoryForCode() const REQUIRES(Locks::jit_lock_) {
171     return exec_end_;
172   }
173 
GetUsedMemoryForData()174   size_t GetUsedMemoryForData() const REQUIRES(Locks::jit_lock_) {
175     return used_memory_for_data_;
176   }
177 
GetResidentMemoryForData()178   size_t GetResidentMemoryForData() const REQUIRES(Locks::jit_lock_) {
179     return data_end_;
180   }
181 
GetWritableDataAddress(const T * src_ptr)182   template <typename T> T* GetWritableDataAddress(const T* src_ptr) {
183     if (!HasDualDataMapping()) {
184       return const_cast<T*>(src_ptr);
185     }
186     return const_cast<T*>(TranslateAddress(src_ptr, data_pages_, writable_data_pages_));
187   }
188 
189  private:
190   template <typename T>
TranslateAddress(T * src_ptr,const MemMap & src,const MemMap & dst)191   T* TranslateAddress(T* src_ptr, const MemMap& src, const MemMap& dst) {
192     CHECK(src.HasAddress(src_ptr)) << reinterpret_cast<const void*>(src_ptr);
193     const uint8_t* const raw_src_ptr = reinterpret_cast<const uint8_t*>(src_ptr);
194     return reinterpret_cast<T*>(raw_src_ptr - src.Begin() + dst.Begin());
195   }
196 
GetUpdatableCodeMapping()197   const MemMap* GetUpdatableCodeMapping() const {
198     if (HasDualCodeMapping()) {
199       return &non_exec_pages_;
200     } else if (HasCodeMapping()) {
201       return &exec_pages_;
202     } else {
203       return nullptr;
204     }
205   }
206 
GetWritableDataMapping()207   const MemMap* GetWritableDataMapping() const {
208     if (HasDualDataMapping()) {
209       return &writable_data_pages_;
210     } else {
211       return &data_pages_;
212     }
213   }
214 
GetNonWritableDataAddress(T * src_ptr)215   template <typename T> T* GetNonWritableDataAddress(T* src_ptr) {
216     if (!HasDualDataMapping()) {
217       return src_ptr;
218     }
219     return TranslateAddress(src_ptr, writable_data_pages_, data_pages_);
220   }
221 
GetExecutableAddress(T * src_ptr)222   template <typename T> T* GetExecutableAddress(T* src_ptr) {
223     if (!HasDualCodeMapping()) {
224       return src_ptr;
225     }
226     return TranslateAddress(src_ptr, non_exec_pages_, exec_pages_);
227   }
228 
GetNonExecutableAddress(T * src_ptr)229   template <typename T> T* GetNonExecutableAddress(T* src_ptr) {
230     if (!HasDualCodeMapping()) {
231       return src_ptr;
232     }
233     return TranslateAddress(src_ptr, exec_pages_, non_exec_pages_);
234   }
235 
236   static int CreateZygoteMemory(size_t capacity, std::string* error_msg);
237   static bool ProtectZygoteMemory(int fd, std::string* error_msg);
238 
239   // The initial capacity in bytes this code region starts with.
240   size_t initial_capacity_ GUARDED_BY(Locks::jit_lock_);
241 
242   // The maximum capacity in bytes this region can go to.
243   size_t max_capacity_ GUARDED_BY(Locks::jit_lock_);
244 
245   // The current capacity in bytes of the region.
246   size_t current_capacity_ GUARDED_BY(Locks::jit_lock_);
247 
248   // The current footprint in bytes of the data portion of the region.
249   size_t data_end_ GUARDED_BY(Locks::jit_lock_);
250 
251   // The current footprint in bytes of the code portion of the region.
252   size_t exec_end_ GUARDED_BY(Locks::jit_lock_);
253 
254   // The size in bytes of used memory for the code portion of the region.
255   size_t used_memory_for_code_ GUARDED_BY(Locks::jit_lock_);
256 
257   // The size in bytes of used memory for the data portion of the region.
258   size_t used_memory_for_data_ GUARDED_BY(Locks::jit_lock_);
259 
260   // Mem map which holds data (stack maps and profiling info).
261   MemMap data_pages_;
262 
263   // Mem map which holds data with writable permission. Only valid for dual view
264   // JIT when this is the writable view and data_pages_ is the readable view.
265   MemMap writable_data_pages_;
266 
267   // Mem map which holds code and has executable permission.
268   MemMap exec_pages_;
269 
270   // Mem map which holds code with non executable permission. Only valid for dual view JIT when
271   // this is the non-executable view of code used to write updates.
272   MemMap non_exec_pages_;
273 
274   // The opaque mspace for allocating data.
275   void* data_mspace_ GUARDED_BY(Locks::jit_lock_);
276 
277   // The opaque mspace for allocating code.
278   void* exec_mspace_ GUARDED_BY(Locks::jit_lock_);
279 
280   friend class ScopedCodeCacheWrite;  // For GetUpdatableCodeMapping
281   friend class TestZygoteMemory;
282 };
283 
284 }  // namespace jit
285 }  // namespace art
286 
287 #endif  // ART_RUNTIME_JIT_JIT_MEMORY_REGION_H_
288