1 /* 2 * Copyright (C) 2011 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_GC_SPACE_IMAGE_SPACE_H_ 18 #define ART_RUNTIME_GC_SPACE_IMAGE_SPACE_H_ 19 20 #include "space.h" 21 22 namespace art { 23 24 class OatFile; 25 26 namespace gc { 27 namespace space { 28 29 // An image space is a space backed with a memory mapped image. 30 class ImageSpace : public MemMapSpace { 31 public: CanAllocateInto()32 bool CanAllocateInto() const { 33 return false; 34 } 35 GetType()36 SpaceType GetType() const { 37 return kSpaceTypeImageSpace; 38 } 39 40 // Create a Space from an image file. Cannot be used for future 41 // allocation or collected. 42 // 43 // Create also opens the OatFile associated with the image file so 44 // that it be contiguously allocated with the image before the 45 // creation of the alloc space. The ReleaseOatFile will later be 46 // used to transfer ownership of the OatFile to the ClassLinker when 47 // it is initialized. 48 static ImageSpace* Create(const std::string& image) 49 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 50 51 // Releases the OatFile from the ImageSpace so it can be transfer to 52 // the caller, presumably the ClassLinker. 53 OatFile& ReleaseOatFile() 54 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 55 56 void VerifyImageAllocations() 57 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 58 GetImageHeader()59 const ImageHeader& GetImageHeader() const { 60 return *reinterpret_cast<ImageHeader*>(Begin()); 61 } 62 GetImageFilename()63 const std::string GetImageFilename() const { 64 return GetName(); 65 } 66 GetLiveBitmap()67 accounting::SpaceBitmap* GetLiveBitmap() const { 68 return live_bitmap_.get(); 69 } 70 GetMarkBitmap()71 accounting::SpaceBitmap* GetMarkBitmap() const { 72 // ImageSpaces have the same bitmap for both live and marked. This helps reduce the number of 73 // special cases to test against. 74 return live_bitmap_.get(); 75 } 76 77 void Dump(std::ostream& os) const; 78 79 private: 80 // Tries to initialize an ImageSpace from the given image path, 81 // returning NULL on error. 82 // 83 // If validate_oat_file is false (for /system), do not verify that 84 // image's OatFile is up-to-date relative to its DexFile 85 // inputs. Otherwise (for /data), validate the inputs and generate 86 // the OatFile in /data/dalvik-cache if necessary. 87 static ImageSpace* Init(const std::string& image, bool validate_oat_file) 88 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 89 90 OatFile* OpenOatFile() const 91 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 92 93 bool ValidateOatFile() const 94 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 95 96 friend class Space; 97 98 static AtomicInteger bitmap_index_; 99 100 UniquePtr<accounting::SpaceBitmap> live_bitmap_; 101 102 ImageSpace(const std::string& name, MemMap* mem_map, accounting::SpaceBitmap* live_bitmap); 103 104 // The OatFile associated with the image during early startup to 105 // reserve space contiguous to the image. It is later released to 106 // the ClassLinker during it's initialization. 107 UniquePtr<OatFile> oat_file_; 108 109 DISALLOW_COPY_AND_ASSIGN(ImageSpace); 110 }; 111 112 } // namespace space 113 } // namespace gc 114 } // namespace art 115 116 #endif // ART_RUNTIME_GC_SPACE_IMAGE_SPACE_H_ 117