1 /* 2 * Copyright (C) 2014 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_PATCHOAT_PATCHOAT_H_ 18 #define ART_PATCHOAT_PATCHOAT_H_ 19 20 #include "arch/instruction_set.h" 21 #include "base/macros.h" 22 #include "base/mutex.h" 23 #include "elf_file.h" 24 #include "elf_utils.h" 25 #include "gc/accounting/space_bitmap.h" 26 #include "gc/space/image_space.h" 27 #include "gc/heap.h" 28 #include "os.h" 29 #include "runtime.h" 30 31 namespace art { 32 33 class ArtMethod; 34 class ImageHeader; 35 class OatHeader; 36 37 namespace mirror { 38 class Object; 39 class PointerArray; 40 class Reference; 41 class Class; 42 } // namespace mirror 43 44 class PatchOat { 45 public: 46 // Patch only the oat file 47 static bool Patch(File* oat_in, off_t delta, File* oat_out, TimingLogger* timings, 48 bool output_oat_opened_from_fd, // Was this using --oatput-oat-fd ? 49 bool new_oat_out); // Output oat was a new file created by us? 50 51 // Patch only the image (art file) 52 static bool Patch(const std::string& art_location, off_t delta, File* art_out, InstructionSet isa, 53 TimingLogger* timings); 54 55 // Patch both the image and the oat file 56 static bool Patch(const std::string& art_location, 57 off_t delta, 58 const std::string& output_directory, 59 InstructionSet isa, 60 TimingLogger* timings); 61 ~PatchOat()62 ~PatchOat() {} 63 PatchOat(PatchOat&&) = default; 64 65 private: 66 // Takes ownership only of the ElfFile. All other pointers are only borrowed. PatchOat(ElfFile * oat_file,off_t delta,TimingLogger * timings)67 PatchOat(ElfFile* oat_file, off_t delta, TimingLogger* timings) 68 : oat_file_(oat_file), image_(nullptr), bitmap_(nullptr), heap_(nullptr), delta_(delta), 69 isa_(kNone), space_map_(nullptr), timings_(timings) {} PatchOat(InstructionSet isa,MemMap * image,gc::accounting::ContinuousSpaceBitmap * bitmap,MemMap * heap,off_t delta,TimingLogger * timings)70 PatchOat(InstructionSet isa, MemMap* image, gc::accounting::ContinuousSpaceBitmap* bitmap, 71 MemMap* heap, off_t delta, TimingLogger* timings) 72 : image_(image), bitmap_(bitmap), heap_(heap), 73 delta_(delta), isa_(isa), space_map_(nullptr), timings_(timings) {} PatchOat(InstructionSet isa,ElfFile * oat_file,MemMap * image,gc::accounting::ContinuousSpaceBitmap * bitmap,MemMap * heap,off_t delta,std::map<gc::space::ImageSpace *,std::unique_ptr<MemMap>> * map,TimingLogger * timings)74 PatchOat(InstructionSet isa, ElfFile* oat_file, MemMap* image, 75 gc::accounting::ContinuousSpaceBitmap* bitmap, MemMap* heap, off_t delta, 76 std::map<gc::space::ImageSpace*, std::unique_ptr<MemMap>>* map, TimingLogger* timings) 77 : oat_file_(oat_file), image_(image), bitmap_(bitmap), heap_(heap), 78 delta_(delta), isa_(isa), space_map_(map), timings_(timings) {} 79 80 // Was the .art image at image_path made with --compile-pic ? 81 static bool IsImagePic(const ImageHeader& image_header, const std::string& image_path); 82 83 enum MaybePic { 84 NOT_PIC, // Code not pic. Patch as usual. 85 PIC, // Code was pic. Create symlink; skip OAT patching. 86 ERROR_OAT_FILE, // Failed to symlink oat file 87 ERROR_FIRST = ERROR_OAT_FILE, 88 }; 89 90 // Was the .oat image at oat_in made with --compile-pic ? 91 static MaybePic IsOatPic(const ElfFile* oat_in); 92 93 // Attempt to replace the file with a symlink 94 // Returns false if it fails 95 static bool ReplaceOatFileWithSymlink(const std::string& input_oat_filename, 96 const std::string& output_oat_filename, 97 bool output_oat_opened_from_fd, 98 bool new_oat_out); // Output oat was newly created? 99 BitmapCallback(mirror::Object * obj,void * arg)100 static void BitmapCallback(mirror::Object* obj, void* arg) 101 SHARED_REQUIRES(Locks::mutator_lock_) { 102 reinterpret_cast<PatchOat*>(arg)->VisitObject(obj); 103 } 104 105 void VisitObject(mirror::Object* obj) 106 SHARED_REQUIRES(Locks::mutator_lock_); 107 void FixupMethod(ArtMethod* object, ArtMethod* copy) 108 SHARED_REQUIRES(Locks::mutator_lock_); 109 110 // Patches oat in place, modifying the oat_file given to the constructor. 111 bool PatchElf(); 112 template <typename ElfFileImpl> 113 bool PatchElf(ElfFileImpl* oat_file); 114 template <typename ElfFileImpl> 115 bool PatchOatHeader(ElfFileImpl* oat_file); 116 117 bool PatchImage(bool primary_image) SHARED_REQUIRES(Locks::mutator_lock_); 118 void PatchArtFields(const ImageHeader* image_header) SHARED_REQUIRES(Locks::mutator_lock_); 119 void PatchArtMethods(const ImageHeader* image_header) SHARED_REQUIRES(Locks::mutator_lock_); 120 void PatchImTables(const ImageHeader* image_header) SHARED_REQUIRES(Locks::mutator_lock_); 121 void PatchImtConflictTables(const ImageHeader* image_header) 122 SHARED_REQUIRES(Locks::mutator_lock_); 123 void PatchInternedStrings(const ImageHeader* image_header) 124 SHARED_REQUIRES(Locks::mutator_lock_); 125 void PatchClassTable(const ImageHeader* image_header) 126 SHARED_REQUIRES(Locks::mutator_lock_); 127 void PatchDexFileArrays(mirror::ObjectArray<mirror::Object>* img_roots) 128 SHARED_REQUIRES(Locks::mutator_lock_); 129 130 bool WriteElf(File* out); 131 bool WriteImage(File* out); 132 133 template <typename T> RelocatedCopyOf(T * obj)134 T* RelocatedCopyOf(T* obj) const { 135 if (obj == nullptr) { 136 return nullptr; 137 } 138 DCHECK_GT(reinterpret_cast<uintptr_t>(obj), reinterpret_cast<uintptr_t>(heap_->Begin())); 139 DCHECK_LT(reinterpret_cast<uintptr_t>(obj), reinterpret_cast<uintptr_t>(heap_->End())); 140 uintptr_t heap_off = 141 reinterpret_cast<uintptr_t>(obj) - reinterpret_cast<uintptr_t>(heap_->Begin()); 142 DCHECK_LT(heap_off, image_->Size()); 143 return reinterpret_cast<T*>(image_->Begin() + heap_off); 144 } 145 146 template <typename T> RelocatedCopyOfFollowImages(T * obj)147 T* RelocatedCopyOfFollowImages(T* obj) const { 148 if (obj == nullptr) { 149 return nullptr; 150 } 151 // Find ImageSpace this belongs to. 152 auto image_spaces = Runtime::Current()->GetHeap()->GetBootImageSpaces(); 153 for (gc::space::ImageSpace* image_space : image_spaces) { 154 if (image_space->Contains(obj)) { 155 uintptr_t heap_off = reinterpret_cast<uintptr_t>(obj) - 156 reinterpret_cast<uintptr_t>(image_space->GetMemMap()->Begin()); 157 return reinterpret_cast<T*>(space_map_->find(image_space)->second->Begin() + heap_off); 158 } 159 } 160 LOG(FATAL) << "Did not find object in boot image space " << obj; 161 UNREACHABLE(); 162 } 163 164 template <typename T> RelocatedAddressOfPointer(T * obj)165 T* RelocatedAddressOfPointer(T* obj) const { 166 if (obj == nullptr) { 167 return obj; 168 } 169 auto ret = reinterpret_cast<uintptr_t>(obj) + delta_; 170 // Trim off high bits in case negative relocation with 64 bit patchoat. 171 if (InstructionSetPointerSize(isa_) == sizeof(uint32_t)) { 172 ret = static_cast<uintptr_t>(static_cast<uint32_t>(ret)); 173 } 174 return reinterpret_cast<T*>(ret); 175 } 176 177 template <typename T> RelocatedAddressOfIntPointer(T obj)178 T RelocatedAddressOfIntPointer(T obj) const { 179 if (obj == 0) { 180 return obj; 181 } 182 T ret = obj + delta_; 183 // Trim off high bits in case negative relocation with 64 bit patchoat. 184 if (InstructionSetPointerSize(isa_) == 4) { 185 ret = static_cast<T>(static_cast<uint32_t>(ret)); 186 } 187 return ret; 188 } 189 190 // Walks through the old image and patches the mmap'd copy of it to the new offset. It does not 191 // change the heap. 192 class PatchVisitor { 193 public: PatchVisitor(PatchOat * patcher,mirror::Object * copy)194 PatchVisitor(PatchOat* patcher, mirror::Object* copy) : patcher_(patcher), copy_(copy) {} ~PatchVisitor()195 ~PatchVisitor() {} 196 void operator() (mirror::Object* obj, MemberOffset off, bool b) const 197 REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_); 198 // For reference classes. 199 void operator() (mirror::Class* cls, mirror::Reference* ref) const 200 REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_); 201 // TODO: Consider using these for updating native class roots? VisitRootIfNonNull(mirror::CompressedReference<mirror::Object> * root ATTRIBUTE_UNUSED)202 void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) 203 const {} VisitRoot(mirror::CompressedReference<mirror::Object> * root ATTRIBUTE_UNUSED)204 void VisitRoot(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) const {} 205 206 private: 207 PatchOat* const patcher_; 208 mirror::Object* const copy_; 209 }; 210 211 // The elf file we are patching. 212 std::unique_ptr<ElfFile> oat_file_; 213 // A mmap of the image we are patching. This is modified. 214 const MemMap* const image_; 215 // The bitmap over the image within the heap we are patching. This is not modified. 216 gc::accounting::ContinuousSpaceBitmap* const bitmap_; 217 // The heap we are patching. This is not modified. 218 const MemMap* const heap_; 219 // The amount we are changing the offset by. 220 const off_t delta_; 221 // Active instruction set, used to know the entrypoint size. 222 const InstructionSet isa_; 223 224 const std::map<gc::space::ImageSpace*, std::unique_ptr<MemMap>>* space_map_; 225 226 TimingLogger* timings_; 227 228 friend class FixupRootVisitor; 229 friend class RelocatedPointerVisitor; 230 friend class PatchOatArtFieldVisitor; 231 friend class PatchOatArtMethodVisitor; 232 DISALLOW_IMPLICIT_CONSTRUCTORS(PatchOat); 233 }; 234 235 } // namespace art 236 #endif // ART_PATCHOAT_PATCHOAT_H_ 237