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