patchoat.cc revision 1c83cbc4a817acbd7f9abb5b29a2d418a958e6a1
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#include "patchoat.h" 17 18#include <stdio.h> 19#include <stdlib.h> 20#include <sys/file.h> 21#include <sys/stat.h> 22#include <unistd.h> 23 24#include <string> 25#include <vector> 26 27#include "base/scoped_flock.h" 28#include "base/stringpiece.h" 29#include "base/stringprintf.h" 30#include "elf_utils.h" 31#include "elf_file.h" 32#include "gc/space/image_space.h" 33#include "image.h" 34#include "instruction_set.h" 35#include "mirror/art_field.h" 36#include "mirror/art_field-inl.h" 37#include "mirror/art_method.h" 38#include "mirror/art_method-inl.h" 39#include "mirror/object.h" 40#include "mirror/object-inl.h" 41#include "mirror/reference.h" 42#include "noop_compiler_callbacks.h" 43#include "offsets.h" 44#include "os.h" 45#include "runtime.h" 46#include "scoped_thread_state_change.h" 47#include "thread.h" 48#include "utils.h" 49 50namespace art { 51 52static InstructionSet ElfISAToInstructionSet(Elf32_Word isa) { 53 switch (isa) { 54 case EM_ARM: 55 return kArm; 56 case EM_AARCH64: 57 return kArm64; 58 case EM_386: 59 return kX86; 60 case EM_X86_64: 61 return kX86_64; 62 case EM_MIPS: 63 return kMips; 64 default: 65 return kNone; 66 } 67} 68 69bool PatchOat::Patch(const std::string& image_location, off_t delta, 70 File* output_image, InstructionSet isa, 71 TimingLogger* timings) { 72 CHECK(Runtime::Current() == nullptr); 73 CHECK(output_image != nullptr); 74 CHECK_GE(output_image->Fd(), 0); 75 CHECK(!image_location.empty()) << "image file must have a filename."; 76 CHECK_NE(isa, kNone); 77 78 TimingLogger::ScopedTiming t("Runtime Setup", timings); 79 const char *isa_name = GetInstructionSetString(isa); 80 std::string image_filename(GetSystemImageFilename(image_location.c_str(), isa)); 81 std::unique_ptr<File> input_image(OS::OpenFileForReading(image_filename.c_str())); 82 if (input_image.get() == nullptr) { 83 LOG(ERROR) << "unable to open input image file."; 84 return false; 85 } 86 int64_t image_len = input_image->GetLength(); 87 if (image_len < 0) { 88 LOG(ERROR) << "Error while getting image length"; 89 return false; 90 } 91 ImageHeader image_header; 92 if (sizeof(image_header) != input_image->Read(reinterpret_cast<char*>(&image_header), 93 sizeof(image_header), 0)) { 94 LOG(ERROR) << "Unable to read image header from image file " << input_image->GetPath(); 95 return false; 96 } 97 98 // Set up the runtime 99 RuntimeOptions options; 100 NoopCompilerCallbacks callbacks; 101 options.push_back(std::make_pair("compilercallbacks", &callbacks)); 102 std::string img = "-Ximage:" + image_location; 103 options.push_back(std::make_pair(img.c_str(), nullptr)); 104 options.push_back(std::make_pair("imageinstructionset", reinterpret_cast<const void*>(isa_name))); 105 if (!Runtime::Create(options, false)) { 106 LOG(ERROR) << "Unable to initialize runtime"; 107 return false; 108 } 109 // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start, 110 // give it away now and then switch to a more manageable ScopedObjectAccess. 111 Thread::Current()->TransitionFromRunnableToSuspended(kNative); 112 ScopedObjectAccess soa(Thread::Current()); 113 114 t.NewTiming("Image and oat Patching setup"); 115 // Create the map where we will write the image patches to. 116 std::string error_msg; 117 std::unique_ptr<MemMap> image(MemMap::MapFile(image_len, PROT_READ | PROT_WRITE, MAP_PRIVATE, 118 input_image->Fd(), 0, 119 input_image->GetPath().c_str(), 120 &error_msg)); 121 if (image.get() == nullptr) { 122 LOG(ERROR) << "unable to map image file " << input_image->GetPath() << " : " << error_msg; 123 return false; 124 } 125 gc::space::ImageSpace* ispc = Runtime::Current()->GetHeap()->GetImageSpace(); 126 127 PatchOat p(image.release(), ispc->GetLiveBitmap(), ispc->GetMemMap(), 128 delta, timings); 129 t.NewTiming("Patching files"); 130 if (!p.PatchImage()) { 131 LOG(ERROR) << "Failed to patch image file " << input_image->GetPath(); 132 return false; 133 } 134 135 t.NewTiming("Writing files"); 136 if (!p.WriteImage(output_image)) { 137 return false; 138 } 139 return true; 140} 141 142bool PatchOat::Patch(const File* input_oat, const std::string& image_location, off_t delta, 143 File* output_oat, File* output_image, InstructionSet isa, 144 TimingLogger* timings) { 145 CHECK(Runtime::Current() == nullptr); 146 CHECK(output_image != nullptr); 147 CHECK_GE(output_image->Fd(), 0); 148 CHECK(input_oat != nullptr); 149 CHECK(output_oat != nullptr); 150 CHECK_GE(input_oat->Fd(), 0); 151 CHECK_GE(output_oat->Fd(), 0); 152 CHECK(!image_location.empty()) << "image file must have a filename."; 153 154 TimingLogger::ScopedTiming t("Runtime Setup", timings); 155 156 if (isa == kNone) { 157 Elf32_Ehdr elf_hdr; 158 if (sizeof(elf_hdr) != input_oat->Read(reinterpret_cast<char*>(&elf_hdr), sizeof(elf_hdr), 0)) { 159 LOG(ERROR) << "unable to read elf header"; 160 return false; 161 } 162 isa = ElfISAToInstructionSet(elf_hdr.e_machine); 163 } 164 const char* isa_name = GetInstructionSetString(isa); 165 std::string image_filename(GetSystemImageFilename(image_location.c_str(), isa)); 166 std::unique_ptr<File> input_image(OS::OpenFileForReading(image_filename.c_str())); 167 if (input_image.get() == nullptr) { 168 LOG(ERROR) << "unable to open input image file."; 169 return false; 170 } 171 int64_t image_len = input_image->GetLength(); 172 if (image_len < 0) { 173 LOG(ERROR) << "Error while getting image length"; 174 return false; 175 } 176 ImageHeader image_header; 177 if (sizeof(image_header) != input_image->Read(reinterpret_cast<char*>(&image_header), 178 sizeof(image_header), 0)) { 179 LOG(ERROR) << "Unable to read image header from image file " << input_image->GetPath(); 180 } 181 182 // Set up the runtime 183 RuntimeOptions options; 184 NoopCompilerCallbacks callbacks; 185 options.push_back(std::make_pair("compilercallbacks", &callbacks)); 186 std::string img = "-Ximage:" + image_location; 187 options.push_back(std::make_pair(img.c_str(), nullptr)); 188 options.push_back(std::make_pair("imageinstructionset", reinterpret_cast<const void*>(isa_name))); 189 if (!Runtime::Create(options, false)) { 190 LOG(ERROR) << "Unable to initialize runtime"; 191 return false; 192 } 193 // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start, 194 // give it away now and then switch to a more manageable ScopedObjectAccess. 195 Thread::Current()->TransitionFromRunnableToSuspended(kNative); 196 ScopedObjectAccess soa(Thread::Current()); 197 198 t.NewTiming("Image and oat Patching setup"); 199 // Create the map where we will write the image patches to. 200 std::string error_msg; 201 std::unique_ptr<MemMap> image(MemMap::MapFile(image_len, PROT_READ | PROT_WRITE, MAP_PRIVATE, 202 input_image->Fd(), 0, 203 input_image->GetPath().c_str(), 204 &error_msg)); 205 if (image.get() == nullptr) { 206 LOG(ERROR) << "unable to map image file " << input_image->GetPath() << " : " << error_msg; 207 return false; 208 } 209 gc::space::ImageSpace* ispc = Runtime::Current()->GetHeap()->GetImageSpace(); 210 211 std::unique_ptr<ElfFile> elf(ElfFile::Open(const_cast<File*>(input_oat), 212 PROT_READ | PROT_WRITE, MAP_PRIVATE, &error_msg)); 213 if (elf.get() == nullptr) { 214 LOG(ERROR) << "unable to open oat file " << input_oat->GetPath() << " : " << error_msg; 215 return false; 216 } 217 218 PatchOat p(elf.release(), image.release(), ispc->GetLiveBitmap(), ispc->GetMemMap(), 219 delta, timings); 220 t.NewTiming("Patching files"); 221 if (!p.PatchElf()) { 222 LOG(ERROR) << "Failed to patch oat file " << input_oat->GetPath(); 223 return false; 224 } 225 if (!p.PatchImage()) { 226 LOG(ERROR) << "Failed to patch image file " << input_image->GetPath(); 227 return false; 228 } 229 230 t.NewTiming("Writing files"); 231 if (!p.WriteElf(output_oat)) { 232 return false; 233 } 234 if (!p.WriteImage(output_image)) { 235 return false; 236 } 237 return true; 238} 239 240bool PatchOat::WriteElf(File* out) { 241 TimingLogger::ScopedTiming t("Writing Elf File", timings_); 242 std::string error_msg; 243 244 // Lock the output file. 245 ScopedFlock flock; 246 flock.Init(out, &error_msg); 247 248 CHECK(oat_file_.get() != nullptr); 249 CHECK(out != nullptr); 250 size_t expect = oat_file_->Size(); 251 if (out->WriteFully(reinterpret_cast<char*>(oat_file_->Begin()), expect) && 252 out->SetLength(expect) == 0) { 253 return true; 254 } else { 255 LOG(ERROR) << "Writing to oat file " << out->GetPath() << " failed."; 256 return false; 257 } 258} 259 260bool PatchOat::WriteImage(File* out) { 261 TimingLogger::ScopedTiming t("Writing image File", timings_); 262 std::string error_msg; 263 264 // Lock the output file. 265 ScopedFlock flock; 266 flock.Init(out, &error_msg); 267 268 CHECK(image_ != nullptr); 269 CHECK(out != nullptr); 270 size_t expect = image_->Size(); 271 if (out->WriteFully(reinterpret_cast<char*>(image_->Begin()), expect) && 272 out->SetLength(expect) == 0) { 273 return true; 274 } else { 275 LOG(ERROR) << "Writing to image file " << out->GetPath() << " failed."; 276 return false; 277 } 278} 279 280bool PatchOat::PatchImage() { 281 ImageHeader* image_header = reinterpret_cast<ImageHeader*>(image_->Begin()); 282 CHECK_GT(image_->Size(), sizeof(ImageHeader)); 283 // These are the roots from the original file. 284 mirror::Object* img_roots = image_header->GetImageRoots(); 285 image_header->RelocateImage(delta_); 286 287 VisitObject(img_roots); 288 if (!image_header->IsValid()) { 289 LOG(ERROR) << "reloction renders image header invalid"; 290 return false; 291 } 292 293 { 294 TimingLogger::ScopedTiming t("Walk Bitmap", timings_); 295 // Walk the bitmap. 296 WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_); 297 bitmap_->Walk(PatchOat::BitmapCallback, this); 298 } 299 return true; 300} 301 302bool PatchOat::InHeap(mirror::Object* o) { 303 uintptr_t begin = reinterpret_cast<uintptr_t>(heap_->Begin()); 304 uintptr_t end = reinterpret_cast<uintptr_t>(heap_->End()); 305 uintptr_t obj = reinterpret_cast<uintptr_t>(o); 306 return o == nullptr || (begin <= obj && obj < end); 307} 308 309void PatchOat::PatchVisitor::operator() (mirror::Object* obj, MemberOffset off, 310 bool is_static_unused) const { 311 mirror::Object* referent = obj->GetFieldObject<mirror::Object, kVerifyNone>(off); 312 DCHECK(patcher_->InHeap(referent)) << "Referent is not in the heap."; 313 mirror::Object* moved_object = patcher_->RelocatedAddressOf(referent); 314 copy_->SetFieldObjectWithoutWriteBarrier<false, true, kVerifyNone>(off, moved_object); 315} 316 317void PatchOat::PatchVisitor::operator() (mirror::Class* cls, mirror::Reference* ref) const { 318 MemberOffset off = mirror::Reference::ReferentOffset(); 319 mirror::Object* referent = ref->GetReferent(); 320 DCHECK(patcher_->InHeap(referent)) << "Referent is not in the heap."; 321 mirror::Object* moved_object = patcher_->RelocatedAddressOf(referent); 322 copy_->SetFieldObjectWithoutWriteBarrier<false, true, kVerifyNone>(off, moved_object); 323} 324 325mirror::Object* PatchOat::RelocatedCopyOf(mirror::Object* obj) { 326 if (obj == nullptr) { 327 return nullptr; 328 } 329 DCHECK_GT(reinterpret_cast<uintptr_t>(obj), reinterpret_cast<uintptr_t>(heap_->Begin())); 330 DCHECK_LT(reinterpret_cast<uintptr_t>(obj), reinterpret_cast<uintptr_t>(heap_->End())); 331 uintptr_t heap_off = 332 reinterpret_cast<uintptr_t>(obj) - reinterpret_cast<uintptr_t>(heap_->Begin()); 333 DCHECK_LT(heap_off, image_->Size()); 334 return reinterpret_cast<mirror::Object*>(image_->Begin() + heap_off); 335} 336 337mirror::Object* PatchOat::RelocatedAddressOf(mirror::Object* obj) { 338 if (obj == nullptr) { 339 return nullptr; 340 } else { 341 return reinterpret_cast<mirror::Object*>(reinterpret_cast<byte*>(obj) + delta_); 342 } 343} 344 345// Called by BitmapCallback 346void PatchOat::VisitObject(mirror::Object* object) { 347 mirror::Object* copy = RelocatedCopyOf(object); 348 CHECK(copy != nullptr); 349 if (kUseBakerOrBrooksReadBarrier) { 350 object->AssertReadBarrierPointer(); 351 if (kUseBrooksReadBarrier) { 352 mirror::Object* moved_to = RelocatedAddressOf(object); 353 copy->SetReadBarrierPointer(moved_to); 354 DCHECK_EQ(copy->GetReadBarrierPointer(), moved_to); 355 } 356 } 357 PatchOat::PatchVisitor visitor(this, copy); 358 object->VisitReferences<true, kVerifyNone>(visitor, visitor); 359 if (object->IsArtMethod<kVerifyNone>()) { 360 FixupMethod(static_cast<mirror::ArtMethod*>(object), 361 static_cast<mirror::ArtMethod*>(copy)); 362 } 363} 364 365void PatchOat::FixupMethod(mirror::ArtMethod* object, mirror::ArtMethod* copy) { 366 // Just update the entry points if it looks like we should. 367 // TODO: sanity check all the pointers' values 368 uintptr_t portable = reinterpret_cast<uintptr_t>( 369 object->GetEntryPointFromPortableCompiledCode<kVerifyNone>()); 370 if (portable != 0) { 371 copy->SetEntryPointFromPortableCompiledCode(reinterpret_cast<void*>(portable + delta_)); 372 } 373 uintptr_t quick= reinterpret_cast<uintptr_t>( 374 object->GetEntryPointFromQuickCompiledCode<kVerifyNone>()); 375 if (quick != 0) { 376 copy->SetEntryPointFromQuickCompiledCode(reinterpret_cast<void*>(quick + delta_)); 377 } 378 uintptr_t interpreter = reinterpret_cast<uintptr_t>( 379 object->GetEntryPointFromInterpreter<kVerifyNone>()); 380 if (interpreter != 0) { 381 copy->SetEntryPointFromInterpreter( 382 reinterpret_cast<mirror::EntryPointFromInterpreter*>(interpreter + delta_)); 383 } 384 385 uintptr_t native_method = reinterpret_cast<uintptr_t>(object->GetNativeMethod()); 386 if (native_method != 0) { 387 copy->SetNativeMethod(reinterpret_cast<void*>(native_method + delta_)); 388 } 389 390 uintptr_t native_gc_map = reinterpret_cast<uintptr_t>(object->GetNativeGcMap()); 391 if (native_gc_map != 0) { 392 copy->SetNativeGcMap(reinterpret_cast<uint8_t*>(native_gc_map + delta_)); 393 } 394} 395 396bool PatchOat::Patch(File* input_oat, off_t delta, File* output_oat, TimingLogger* timings) { 397 CHECK(input_oat != nullptr); 398 CHECK(output_oat != nullptr); 399 CHECK_GE(input_oat->Fd(), 0); 400 CHECK_GE(output_oat->Fd(), 0); 401 TimingLogger::ScopedTiming t("Setup Oat File Patching", timings); 402 403 std::string error_msg; 404 std::unique_ptr<ElfFile> elf(ElfFile::Open(const_cast<File*>(input_oat), 405 PROT_READ | PROT_WRITE, MAP_PRIVATE, &error_msg)); 406 if (elf.get() == nullptr) { 407 LOG(ERROR) << "unable to open oat file " << input_oat->GetPath() << " : " << error_msg; 408 return false; 409 } 410 411 PatchOat p(elf.release(), delta, timings); 412 t.NewTiming("Patch Oat file"); 413 if (!p.PatchElf()) { 414 return false; 415 } 416 417 t.NewTiming("Writing oat file"); 418 if (!p.WriteElf(output_oat)) { 419 return false; 420 } 421 return true; 422} 423 424bool PatchOat::CheckOatFile() { 425 Elf32_Shdr* patches_sec = oat_file_->FindSectionByName(".oat_patches"); 426 if (patches_sec == nullptr) { 427 return false; 428 } 429 if (patches_sec->sh_type != SHT_OAT_PATCH) { 430 return false; 431 } 432 uintptr_t* patches = reinterpret_cast<uintptr_t*>(oat_file_->Begin() + patches_sec->sh_offset); 433 uintptr_t* patches_end = patches + (patches_sec->sh_size/sizeof(uintptr_t)); 434 Elf32_Shdr* oat_data_sec = oat_file_->FindSectionByName(".rodata"); 435 Elf32_Shdr* oat_text_sec = oat_file_->FindSectionByName(".text"); 436 if (oat_data_sec == nullptr) { 437 return false; 438 } 439 if (oat_text_sec == nullptr) { 440 return false; 441 } 442 if (oat_text_sec->sh_offset <= oat_data_sec->sh_offset) { 443 return false; 444 } 445 446 for (; patches < patches_end; patches++) { 447 if (oat_text_sec->sh_size <= *patches) { 448 return false; 449 } 450 } 451 452 return true; 453} 454 455bool PatchOat::PatchOatHeader() { 456 Elf32_Shdr *rodata_sec = oat_file_->FindSectionByName(".rodata"); 457 if (rodata_sec == nullptr) { 458 return false; 459 } 460 OatHeader* oat_header = reinterpret_cast<OatHeader*>(oat_file_->Begin() + rodata_sec->sh_offset); 461 if (!oat_header->IsValid()) { 462 LOG(ERROR) << "Elf file " << oat_file_->GetFile().GetPath() << " has an invalid oat header"; 463 return false; 464 } 465 oat_header->RelocateOat(delta_); 466 return true; 467} 468 469bool PatchOat::PatchElf() { 470 TimingLogger::ScopedTiming t("Fixup Elf Text Section", timings_); 471 if (!PatchTextSection()) { 472 return false; 473 } 474 475 if (!PatchOatHeader()) { 476 return false; 477 } 478 479 bool need_fixup = false; 480 t.NewTiming("Fixup Elf Headers"); 481 // Fixup Phdr's 482 for (unsigned int i = 0; i < oat_file_->GetProgramHeaderNum(); i++) { 483 Elf32_Phdr& hdr = oat_file_->GetProgramHeader(i); 484 if (hdr.p_vaddr != 0 && hdr.p_vaddr != hdr.p_offset) { 485 need_fixup = true; 486 hdr.p_vaddr += delta_; 487 } 488 if (hdr.p_paddr != 0 && hdr.p_paddr != hdr.p_offset) { 489 need_fixup = true; 490 hdr.p_paddr += delta_; 491 } 492 } 493 if (!need_fixup) { 494 // This was never passed through ElfFixup so all headers/symbols just have their offset as 495 // their addr. Therefore we do not need to update these parts. 496 return true; 497 } 498 t.NewTiming("Fixup Section Headers"); 499 for (unsigned int i = 0; i < oat_file_->GetSectionHeaderNum(); i++) { 500 Elf32_Shdr& hdr = oat_file_->GetSectionHeader(i); 501 if (hdr.sh_addr != 0) { 502 hdr.sh_addr += delta_; 503 } 504 } 505 506 t.NewTiming("Fixup Dynamics"); 507 for (Elf32_Word i = 0; i < oat_file_->GetDynamicNum(); i++) { 508 Elf32_Dyn& dyn = oat_file_->GetDynamic(i); 509 if (IsDynamicSectionPointer(dyn.d_tag, oat_file_->GetHeader().e_machine)) { 510 dyn.d_un.d_ptr += delta_; 511 } 512 } 513 514 t.NewTiming("Fixup Elf Symbols"); 515 // Fixup dynsym 516 Elf32_Shdr* dynsym_sec = oat_file_->FindSectionByName(".dynsym"); 517 CHECK(dynsym_sec != nullptr); 518 if (!PatchSymbols(dynsym_sec)) { 519 return false; 520 } 521 522 // Fixup symtab 523 Elf32_Shdr* symtab_sec = oat_file_->FindSectionByName(".symtab"); 524 if (symtab_sec != nullptr) { 525 if (!PatchSymbols(symtab_sec)) { 526 return false; 527 } 528 } 529 530 return true; 531} 532 533bool PatchOat::PatchSymbols(Elf32_Shdr* section) { 534 Elf32_Sym* syms = reinterpret_cast<Elf32_Sym*>(oat_file_->Begin() + section->sh_offset); 535 const Elf32_Sym* last_sym = 536 reinterpret_cast<Elf32_Sym*>(oat_file_->Begin() + section->sh_offset + section->sh_size); 537 CHECK_EQ(section->sh_size % sizeof(Elf32_Sym), 0u) 538 << "Symtab section size is not multiple of symbol size"; 539 for (; syms < last_sym; syms++) { 540 uint8_t sttype = ELF32_ST_TYPE(syms->st_info); 541 Elf32_Word shndx = syms->st_shndx; 542 if (shndx != SHN_ABS && shndx != SHN_COMMON && shndx != SHN_UNDEF && 543 (sttype == STT_FUNC || sttype == STT_OBJECT)) { 544 CHECK_NE(syms->st_value, 0u); 545 syms->st_value += delta_; 546 } 547 } 548 return true; 549} 550 551bool PatchOat::PatchTextSection() { 552 Elf32_Shdr* patches_sec = oat_file_->FindSectionByName(".oat_patches"); 553 if (patches_sec == nullptr) { 554 LOG(ERROR) << ".oat_patches section not found. Aborting patch"; 555 return false; 556 } 557 DCHECK(CheckOatFile()) << "Oat file invalid"; 558 CHECK_EQ(patches_sec->sh_type, SHT_OAT_PATCH) << "Unexpected type of .oat_patches"; 559 uintptr_t* patches = reinterpret_cast<uintptr_t*>(oat_file_->Begin() + patches_sec->sh_offset); 560 uintptr_t* patches_end = patches + (patches_sec->sh_size/sizeof(uintptr_t)); 561 Elf32_Shdr* oat_text_sec = oat_file_->FindSectionByName(".text"); 562 CHECK(oat_text_sec != nullptr); 563 byte* to_patch = oat_file_->Begin() + oat_text_sec->sh_offset; 564 uintptr_t to_patch_end = reinterpret_cast<uintptr_t>(to_patch) + oat_text_sec->sh_size; 565 566 for (; patches < patches_end; patches++) { 567 CHECK_LT(*patches, oat_text_sec->sh_size) << "Bad Patch"; 568 uint32_t* patch_loc = reinterpret_cast<uint32_t*>(to_patch + *patches); 569 CHECK_LT(reinterpret_cast<uintptr_t>(patch_loc), to_patch_end); 570 *patch_loc += delta_; 571 } 572 573 return true; 574} 575 576static int orig_argc; 577static char** orig_argv; 578 579static std::string CommandLine() { 580 std::vector<std::string> command; 581 for (int i = 0; i < orig_argc; ++i) { 582 command.push_back(orig_argv[i]); 583 } 584 return Join(command, ' '); 585} 586 587static void UsageErrorV(const char* fmt, va_list ap) { 588 std::string error; 589 StringAppendV(&error, fmt, ap); 590 LOG(ERROR) << error; 591} 592 593static void UsageError(const char* fmt, ...) { 594 va_list ap; 595 va_start(ap, fmt); 596 UsageErrorV(fmt, ap); 597 va_end(ap); 598} 599 600static void Usage(const char *fmt, ...) { 601 va_list ap; 602 va_start(ap, fmt); 603 UsageErrorV(fmt, ap); 604 va_end(ap); 605 606 UsageError("Command: %s", CommandLine().c_str()); 607 UsageError("Usage: patchoat [options]..."); 608 UsageError(""); 609 UsageError(" --instruction-set=<isa>: Specifies the instruction set the patched code is"); 610 UsageError(" compiled for. Required if you use --input-oat-location"); 611 UsageError(""); 612 UsageError(" --input-oat-file=<file.oat>: Specifies the exact filename of the oat file to be"); 613 UsageError(" patched."); 614 UsageError(""); 615 UsageError(" --input-oat-fd=<file-descriptor>: Specifies the file-descriptor of the oat file"); 616 UsageError(" to be patched."); 617 UsageError(""); 618 UsageError(" --input-oat-location=<file.oat>: Specifies the 'location' to read the patched"); 619 UsageError(" oat file from. If used one must also supply the --instruction-set"); 620 UsageError(""); 621 UsageError(" --input-image-location=<file.art>: Specifies the 'location' of the image file to"); 622 UsageError(" be patched. If --instruction-set is not given it will use the instruction set"); 623 UsageError(" extracted from the --input-oat-file."); 624 UsageError(""); 625 UsageError(" --output-oat-file=<file.oat>: Specifies the exact file to write the patched oat"); 626 UsageError(" file to."); 627 UsageError(""); 628 UsageError(" --output-oat-location=<file.oat>: Specifies the 'location' to write the patched"); 629 UsageError(" oat file to. If used one must also specify the --instruction-set"); 630 UsageError(""); 631 UsageError(" --output-oat-fd=<file-descriptor>: Specifies the file-descriptor to write the"); 632 UsageError(" the patched oat file to."); 633 UsageError(""); 634 UsageError(" --output-image-file=<file.art>: Specifies the exact file to write the patched"); 635 UsageError(" image file to."); 636 UsageError(""); 637 UsageError(" --output-image-fd=<file-descriptor>: Specifies the file-descriptor to write the"); 638 UsageError(" the patched image file to."); 639 UsageError(""); 640 UsageError(" --output-image-location=<file.art>: Specifies the 'location' to write the patched"); 641 UsageError(" image file to. If used one must also specify the --instruction-set"); 642 UsageError(""); 643 UsageError(" --orig-base-offset=<original-base-offset>: Specify the base offset the input file"); 644 UsageError(" was compiled with. This is needed if one is specifying a --base-offset"); 645 UsageError(""); 646 UsageError(" --base-offset=<new-base-offset>: Specify the base offset we will repatch the"); 647 UsageError(" given files to use. This requires that --orig-base-offset is also given."); 648 UsageError(""); 649 UsageError(" --base-offset-delta=<delta>: Specify the amount to change the old base-offset by."); 650 UsageError(" This value may be negative."); 651 UsageError(""); 652 UsageError(" --patched-image-file=<file.art>: Use the same patch delta as was used to patch"); 653 UsageError(" the given image file."); 654 UsageError(""); 655 UsageError(" --patched-image-location=<file.art>: Use the same patch delta as was used to"); 656 UsageError(" patch the given image location. If used one must also specify the"); 657 UsageError(" --instruction-set flag. It will search for this image in the same way that"); 658 UsageError(" is done when loading one."); 659 UsageError(""); 660 UsageError(" --dump-timings: dump out patch timing information"); 661 UsageError(""); 662 UsageError(" --no-dump-timings: do not dump out patch timing information"); 663 UsageError(""); 664 665 exit(EXIT_FAILURE); 666} 667 668static bool ReadBaseDelta(const char* name, off_t* delta, std::string* error_msg) { 669 CHECK(name != nullptr); 670 CHECK(delta != nullptr); 671 std::unique_ptr<File> file; 672 if (OS::FileExists(name)) { 673 file.reset(OS::OpenFileForReading(name)); 674 if (file.get() == nullptr) { 675 *error_msg = "Failed to open file %s for reading"; 676 return false; 677 } 678 } else { 679 *error_msg = "File %s does not exist"; 680 return false; 681 } 682 CHECK(file.get() != nullptr); 683 ImageHeader hdr; 684 if (sizeof(hdr) != file->Read(reinterpret_cast<char*>(&hdr), sizeof(hdr), 0)) { 685 *error_msg = "Failed to read file %s"; 686 return false; 687 } 688 if (!hdr.IsValid()) { 689 *error_msg = "%s does not contain a valid image header."; 690 return false; 691 } 692 *delta = hdr.GetPatchDelta(); 693 return true; 694} 695 696static File* CreateOrOpen(const char* name, bool* created) { 697 if (OS::FileExists(name)) { 698 *created = false; 699 return OS::OpenFileReadWrite(name); 700 } else { 701 *created = true; 702 return OS::CreateEmptyFile(name); 703 } 704} 705 706static int patchoat(int argc, char **argv) { 707 InitLogging(argv); 708 const bool debug = kIsDebugBuild; 709 orig_argc = argc; 710 orig_argv = argv; 711 TimingLogger timings("patcher", false, false); 712 713 InitLogging(argv); 714 715 // Skip over the command name. 716 argv++; 717 argc--; 718 719 if (argc == 0) { 720 Usage("No arguments specified"); 721 } 722 723 timings.StartTiming("Patchoat"); 724 725 // cmd line args 726 bool isa_set = false; 727 InstructionSet isa = kNone; 728 std::string input_oat_filename; 729 std::string input_oat_location; 730 int input_oat_fd = -1; 731 bool have_input_oat = false; 732 std::string input_image_location; 733 std::string output_oat_filename; 734 std::string output_oat_location; 735 int output_oat_fd = -1; 736 bool have_output_oat = false; 737 std::string output_image_filename; 738 std::string output_image_location; 739 int output_image_fd = -1; 740 bool have_output_image = false; 741 uintptr_t base_offset = 0; 742 bool base_offset_set = false; 743 uintptr_t orig_base_offset = 0; 744 bool orig_base_offset_set = false; 745 off_t base_delta = 0; 746 bool base_delta_set = false; 747 std::string patched_image_filename; 748 std::string patched_image_location; 749 bool dump_timings = kIsDebugBuild; 750 751 for (int i = 0; i < argc; i++) { 752 const StringPiece option(argv[i]); 753 const bool log_options = false; 754 if (log_options) { 755 LOG(INFO) << "patchoat: option[" << i << "]=" << argv[i]; 756 } 757 // TODO: GetInstructionSetFromString shouldn't LOG(FATAL). 758 if (option.starts_with("--instruction-set=")) { 759 isa_set = true; 760 const char* isa_str = option.substr(strlen("--instruction-set=")).data(); 761 if (!strcmp("arm", isa_str)) { 762 isa = kArm; 763 } else if (!strcmp("arm64", isa_str)) { 764 isa = kArm64; 765 } else if (!strcmp("x86", isa_str)) { 766 isa = kX86; 767 } else if (!strcmp("x86_64", isa_str)) { 768 isa = kX86_64; 769 } else if (!strcmp("mips", isa_str)) { 770 isa = kMips; 771 } else { 772 Usage("Unknown instruction set %s", isa_str); 773 } 774 } else if (option.starts_with("--input-oat-location=")) { 775 if (have_input_oat) { 776 Usage("Only one of --input-oat-file, --input-oat-location and --input-oat-fd may be used."); 777 } 778 have_input_oat = true; 779 input_oat_location = option.substr(strlen("--input-oat-location=")).data(); 780 } else if (option.starts_with("--input-oat-file=")) { 781 if (have_input_oat) { 782 Usage("Only one of --input-oat-file, --input-oat-location and --input-oat-fd may be used."); 783 } 784 have_input_oat = true; 785 input_oat_filename = option.substr(strlen("--input-oat-file=")).data(); 786 } else if (option.starts_with("--input-oat-fd=")) { 787 if (have_input_oat) { 788 Usage("Only one of --input-oat-file, --input-oat-location and --input-oat-fd may be used."); 789 } 790 have_input_oat = true; 791 const char* oat_fd_str = option.substr(strlen("--input-oat-fd=")).data(); 792 if (!ParseInt(oat_fd_str, &input_oat_fd)) { 793 Usage("Failed to parse --input-oat-fd argument '%s' as an integer", oat_fd_str); 794 } 795 if (input_oat_fd < 0) { 796 Usage("--input-oat-fd pass a negative value %d", input_oat_fd); 797 } 798 } else if (option.starts_with("--input-image-location=")) { 799 input_image_location = option.substr(strlen("--input-image-location=")).data(); 800 } else if (option.starts_with("--output-oat-location=")) { 801 if (have_output_oat) { 802 Usage("Only one of --output-oat-file, --output-oat-location and --output-oat-fd may " 803 "be used."); 804 } 805 have_output_oat = true; 806 output_oat_location = option.substr(strlen("--output-oat-location=")).data(); 807 } else if (option.starts_with("--output-oat-file=")) { 808 if (have_output_oat) { 809 Usage("Only one of --output-oat-file, --output-oat-location and --output-oat-fd may " 810 "be used."); 811 } 812 have_output_oat = true; 813 output_oat_filename = option.substr(strlen("--output-oat-file=")).data(); 814 } else if (option.starts_with("--output-oat-fd=")) { 815 if (have_output_oat) { 816 Usage("Only one of --output-oat-file, --output-oat-location and --output-oat-fd may " 817 "be used."); 818 } 819 have_output_oat = true; 820 const char* oat_fd_str = option.substr(strlen("--output-oat-fd=")).data(); 821 if (!ParseInt(oat_fd_str, &output_oat_fd)) { 822 Usage("Failed to parse --output-oat-fd argument '%s' as an integer", oat_fd_str); 823 } 824 if (output_oat_fd < 0) { 825 Usage("--output-oat-fd pass a negative value %d", output_oat_fd); 826 } 827 } else if (option.starts_with("--output-image-location=")) { 828 if (have_output_image) { 829 Usage("Only one of --output-image-file, --output-image-location and --output-image-fd may " 830 "be used."); 831 } 832 have_output_image = true; 833 output_image_location= option.substr(strlen("--output-image-location=")).data(); 834 } else if (option.starts_with("--output-image-file=")) { 835 if (have_output_image) { 836 Usage("Only one of --output-image-file, --output-image-location and --output-image-fd may " 837 "be used."); 838 } 839 have_output_image = true; 840 output_image_filename = option.substr(strlen("--output-image-file=")).data(); 841 } else if (option.starts_with("--output-image-fd=")) { 842 if (have_output_image) { 843 Usage("Only one of --output-image-file, --output-image-location and --output-image-fd " 844 "may be used."); 845 } 846 have_output_image = true; 847 const char* image_fd_str = option.substr(strlen("--output-image-fd=")).data(); 848 if (!ParseInt(image_fd_str, &output_image_fd)) { 849 Usage("Failed to parse --output-image-fd argument '%s' as an integer", image_fd_str); 850 } 851 if (output_image_fd < 0) { 852 Usage("--output-image-fd pass a negative value %d", output_image_fd); 853 } 854 } else if (option.starts_with("--orig-base-offset=")) { 855 const char* orig_base_offset_str = option.substr(strlen("--orig-base-offset=")).data(); 856 orig_base_offset_set = true; 857 if (!ParseUint(orig_base_offset_str, &orig_base_offset)) { 858 Usage("Failed to parse --orig-base-offset argument '%s' as an uintptr_t", 859 orig_base_offset_str); 860 } 861 } else if (option.starts_with("--base-offset=")) { 862 const char* base_offset_str = option.substr(strlen("--base-offset=")).data(); 863 base_offset_set = true; 864 if (!ParseUint(base_offset_str, &base_offset)) { 865 Usage("Failed to parse --base-offset argument '%s' as an uintptr_t", base_offset_str); 866 } 867 } else if (option.starts_with("--base-offset-delta=")) { 868 const char* base_delta_str = option.substr(strlen("--base-offset-delta=")).data(); 869 base_delta_set = true; 870 if (!ParseInt(base_delta_str, &base_delta)) { 871 Usage("Failed to parse --base-offset-delta argument '%s' as an off_t", base_delta_str); 872 } 873 } else if (option.starts_with("--patched-image-location=")) { 874 patched_image_location = option.substr(strlen("--patched-image-location=")).data(); 875 } else if (option.starts_with("--patched-image-file=")) { 876 patched_image_filename = option.substr(strlen("--patched-image-file=")).data(); 877 } else if (option == "--dump-timings") { 878 dump_timings = true; 879 } else if (option == "--no-dump-timings") { 880 dump_timings = false; 881 } else { 882 Usage("Unknown argument %s", option.data()); 883 } 884 } 885 886 { 887 // Only 1 of these may be set. 888 uint32_t cnt = 0; 889 cnt += (base_delta_set) ? 1 : 0; 890 cnt += (base_offset_set && orig_base_offset_set) ? 1 : 0; 891 cnt += (!patched_image_filename.empty()) ? 1 : 0; 892 cnt += (!patched_image_location.empty()) ? 1 : 0; 893 if (cnt > 1) { 894 Usage("Only one of --base-offset/--orig-base-offset, --base-offset-delta, " 895 "--patched-image-filename or --patched-image-location may be used."); 896 } else if (cnt == 0) { 897 Usage("Must specify --base-offset-delta, --base-offset and --orig-base-offset, " 898 "--patched-image-location or --patched-image-file"); 899 } 900 } 901 902 if (have_input_oat != have_output_oat) { 903 Usage("Either both input and output oat must be supplied or niether must be."); 904 } 905 906 if ((!input_image_location.empty()) != have_output_image) { 907 Usage("Either both input and output image must be supplied or niether must be."); 908 } 909 910 // We know we have both the input and output so rename for clarity. 911 bool have_image_files = have_output_image; 912 bool have_oat_files = have_output_oat; 913 914 if (!have_oat_files && !have_image_files) { 915 Usage("Must be patching either an oat or an image file or both."); 916 } 917 918 if (!have_oat_files && !isa_set) { 919 Usage("Must include ISA if patching an image file without an oat file."); 920 } 921 922 if (!input_oat_location.empty()) { 923 if (!isa_set) { 924 Usage("specifying a location requires specifying an instruction set"); 925 } 926 input_oat_filename = GetSystemImageFilename(input_oat_location.c_str(), isa); 927 if (debug) { 928 LOG(INFO) << "Using input-oat-file " << input_oat_filename; 929 } 930 } 931 if (!output_oat_location.empty()) { 932 if (!isa_set) { 933 Usage("specifying a location requires specifying an instruction set"); 934 } 935 output_oat_filename = GetSystemImageFilename(output_oat_location.c_str(), isa); 936 if (debug) { 937 LOG(INFO) << "Using output-oat-file " << output_oat_filename; 938 } 939 } 940 if (!output_image_location.empty()) { 941 if (!isa_set) { 942 Usage("specifying a location requires specifying an instruction set"); 943 } 944 output_image_filename = GetSystemImageFilename(output_image_location.c_str(), isa); 945 if (debug) { 946 LOG(INFO) << "Using output-image-file " << output_image_filename; 947 } 948 } 949 if (!patched_image_location.empty()) { 950 if (!isa_set) { 951 Usage("specifying a location requires specifying an instruction set"); 952 } 953 std::string system_filename; 954 bool has_system = false; 955 std::string cache_filename; 956 bool has_cache = false; 957 bool has_android_data_unused = false; 958 if (!gc::space::ImageSpace::FindImageFilename(patched_image_location.c_str(), isa, 959 &system_filename, &has_system, &cache_filename, 960 &has_android_data_unused, &has_cache)) { 961 Usage("Unable to determine image file for location %s", patched_image_location.c_str()); 962 } 963 if (has_cache) { 964 patched_image_filename = cache_filename; 965 } else if (has_system) { 966 LOG(WARNING) << "Only image file found was in /system for image location " 967 << patched_image_location; 968 patched_image_filename = system_filename; 969 } else { 970 Usage("Unable to determine image file for location %s", patched_image_location.c_str()); 971 } 972 if (debug) { 973 LOG(INFO) << "Using patched-image-file " << patched_image_filename; 974 } 975 } 976 977 if (!base_delta_set) { 978 if (orig_base_offset_set && base_offset_set) { 979 base_delta_set = true; 980 base_delta = base_offset - orig_base_offset; 981 } else if (!patched_image_filename.empty()) { 982 base_delta_set = true; 983 std::string error_msg; 984 if (!ReadBaseDelta(patched_image_filename.c_str(), &base_delta, &error_msg)) { 985 Usage(error_msg.c_str(), patched_image_filename.c_str()); 986 } 987 } else { 988 if (base_offset_set) { 989 Usage("Unable to determine original base offset."); 990 } else { 991 Usage("Must supply a desired new offset or delta."); 992 } 993 } 994 } 995 996 if (!IsAligned<kPageSize>(base_delta)) { 997 Usage("Base offset/delta must be alligned to a pagesize (0x%08x) boundary.", kPageSize); 998 } 999 1000 // Do we need to cleanup output files if we fail? 1001 bool new_image_out = false; 1002 bool new_oat_out = false; 1003 1004 std::unique_ptr<File> input_oat; 1005 std::unique_ptr<File> output_oat; 1006 std::unique_ptr<File> output_image; 1007 1008 if (have_image_files) { 1009 CHECK(!input_image_location.empty()); 1010 1011 if (output_image_fd != -1) { 1012 output_image.reset(new File(output_image_fd, output_image_filename)); 1013 } else { 1014 CHECK(!output_image_filename.empty()); 1015 output_image.reset(CreateOrOpen(output_image_filename.c_str(), &new_image_out)); 1016 } 1017 } else { 1018 CHECK(output_image_filename.empty() && output_image_fd == -1 && input_image_location.empty()); 1019 } 1020 1021 if (have_oat_files) { 1022 if (input_oat_fd != -1) { 1023 input_oat.reset(new File(input_oat_fd, input_oat_filename)); 1024 } else { 1025 CHECK(!input_oat_filename.empty()); 1026 input_oat.reset(OS::OpenFileForReading(input_oat_filename.c_str())); 1027 if (input_oat.get() == nullptr) { 1028 LOG(ERROR) << "Could not open input oat file: " << strerror(errno); 1029 } 1030 } 1031 1032 if (output_oat_fd != -1) { 1033 output_oat.reset(new File(output_oat_fd, output_oat_filename)); 1034 } else if (output_oat_filename == input_oat_filename) { 1035 // This could be a wierd situation, since we'd be writting from an mmap'd copy of this file. 1036 // Lets just unlink it. 1037 if (0 != unlink(input_oat_filename.c_str())) { 1038 PLOG(ERROR) << "Could not unlink " << input_oat_filename << " to make room for output"; 1039 return false; 1040 } 1041 output_oat.reset(OS::CreateEmptyFile(output_oat_filename.c_str())); 1042 } else { 1043 CHECK(!output_oat_filename.empty()); 1044 output_oat.reset(CreateOrOpen(output_oat_filename.c_str(), &new_oat_out)); 1045 } 1046 } 1047 1048 auto cleanup = [&output_image_filename, &output_oat_filename, 1049 &new_oat_out, &new_image_out, &timings, &dump_timings](bool success) { 1050 timings.EndTiming(); 1051 if (!success) { 1052 if (new_oat_out) { 1053 CHECK(!output_oat_filename.empty()); 1054 unlink(output_oat_filename.c_str()); 1055 } 1056 if (new_image_out) { 1057 CHECK(!output_image_filename.empty()); 1058 unlink(output_image_filename.c_str()); 1059 } 1060 } 1061 if (dump_timings) { 1062 LOG(INFO) << Dumpable<TimingLogger>(timings); 1063 } 1064 }; 1065 1066 if (debug) { 1067 LOG(INFO) << "moving offset by " << base_delta 1068 << " (0x" << std::hex << base_delta << ") bytes or " 1069 << std::dec << (base_delta/kPageSize) << " pages."; 1070 } 1071 1072 bool ret; 1073 if (have_image_files && have_oat_files) { 1074 TimingLogger::ScopedTiming pt("patch image and oat", &timings); 1075 ret = PatchOat::Patch(input_oat.get(), input_image_location, base_delta, 1076 output_oat.get(), output_image.get(), isa, &timings); 1077 } else if (have_oat_files) { 1078 TimingLogger::ScopedTiming pt("patch oat", &timings); 1079 ret = PatchOat::Patch(input_oat.get(), base_delta, output_oat.get(), &timings); 1080 } else { 1081 TimingLogger::ScopedTiming pt("patch image", &timings); 1082 CHECK(have_image_files); 1083 ret = PatchOat::Patch(input_image_location, base_delta, output_image.get(), isa, &timings); 1084 } 1085 cleanup(ret); 1086 sync(); 1087 return (ret) ? EXIT_SUCCESS : EXIT_FAILURE; 1088} 1089 1090} // namespace art 1091 1092int main(int argc, char **argv) { 1093 return art::patchoat(argc, argv); 1094} 1095