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 "base/macros.h" 21 #include "base/mutex.h" 22 #include "instruction_set.h" 23 #include "os.h" 24 #include "elf_file.h" 25 #include "elf_utils.h" 26 #include "gc/accounting/space_bitmap.h" 27 #include "gc/heap.h" 28 #include "utils.h" 29 30 namespace art { 31 32 class ImageHeader; 33 34 namespace mirror { 35 class Object; 36 class Reference; 37 class Class; 38 class ArtMethod; 39 }; // namespace mirror 40 41 class PatchOat { 42 public: 43 static bool Patch(File* oat_in, off_t delta, File* oat_out, TimingLogger* timings); 44 45 static bool Patch(const std::string& art_location, off_t delta, File* art_out, InstructionSet isa, 46 TimingLogger* timings); 47 48 static bool Patch(const File* oat_in, const std::string& art_location, 49 off_t delta, File* oat_out, File* art_out, InstructionSet isa, 50 TimingLogger* timings); 51 52 private: 53 // Takes ownership only of the ElfFile. All other pointers are only borrowed. PatchOat(ElfFile * oat_file,off_t delta,TimingLogger * timings)54 PatchOat(ElfFile* oat_file, off_t delta, TimingLogger* timings) 55 : oat_file_(oat_file), delta_(delta), timings_(timings) {} PatchOat(MemMap * image,gc::accounting::ContinuousSpaceBitmap * bitmap,MemMap * heap,off_t delta,TimingLogger * timings)56 PatchOat(MemMap* image, gc::accounting::ContinuousSpaceBitmap* bitmap, 57 MemMap* heap, off_t delta, TimingLogger* timings) 58 : image_(image), bitmap_(bitmap), heap_(heap), 59 delta_(delta), timings_(timings) {} PatchOat(ElfFile * oat_file,MemMap * image,gc::accounting::ContinuousSpaceBitmap * bitmap,MemMap * heap,off_t delta,TimingLogger * timings)60 PatchOat(ElfFile* oat_file, MemMap* image, gc::accounting::ContinuousSpaceBitmap* bitmap, 61 MemMap* heap, off_t delta, TimingLogger* timings) 62 : oat_file_(oat_file), image_(image), bitmap_(bitmap), heap_(heap), 63 delta_(delta), timings_(timings) {} ~PatchOat()64 ~PatchOat() {} 65 BitmapCallback(mirror::Object * obj,void * arg)66 static void BitmapCallback(mirror::Object* obj, void* arg) 67 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 68 reinterpret_cast<PatchOat*>(arg)->VisitObject(obj); 69 } 70 71 void VisitObject(mirror::Object* obj) 72 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 73 void FixupMethod(mirror::ArtMethod* object, mirror::ArtMethod* copy) 74 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 75 bool InHeap(mirror::Object*); 76 77 bool CheckOatFile(); 78 79 // Patches oat in place, modifying the oat_file given to the constructor. 80 bool PatchElf(); 81 bool PatchTextSection(); 82 bool PatchOatHeader(); 83 bool PatchSymbols(Elf32_Shdr* section); 84 85 bool PatchImage() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 86 87 bool WriteElf(File* out); 88 bool WriteImage(File* out); 89 90 mirror::Object* RelocatedCopyOf(mirror::Object*); 91 mirror::Object* RelocatedAddressOf(mirror::Object* obj); 92 93 // Walks through the old image and patches the mmap'd copy of it to the new offset. It does not 94 // change the heap. 95 class PatchVisitor { 96 public: PatchVisitor(PatchOat * patcher,mirror::Object * copy)97 PatchVisitor(PatchOat* patcher, mirror::Object* copy) : patcher_(patcher), copy_(copy) {} ~PatchVisitor()98 ~PatchVisitor() {} 99 void operator() (mirror::Object* obj, MemberOffset off, bool b) const 100 EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_); 101 // For reference classes. 102 void operator() (mirror::Class* cls, mirror::Reference* ref) const 103 EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_); 104 private: 105 PatchOat* patcher_; 106 mirror::Object* copy_; 107 }; 108 109 // The elf file we are patching. 110 std::unique_ptr<ElfFile> oat_file_; 111 // A mmap of the image we are patching. This is modified. 112 const MemMap* image_; 113 // The heap we are patching. This is not modified. 114 gc::accounting::ContinuousSpaceBitmap* bitmap_; 115 // The heap we are patching. This is not modified. 116 const MemMap* heap_; 117 // The amount we are changing the offset by. 118 off_t delta_; 119 TimingLogger* timings_; 120 121 DISALLOW_IMPLICIT_CONSTRUCTORS(PatchOat); 122 }; 123 124 } // namespace art 125 #endif // ART_PATCHOAT_PATCHOAT_H_ 126