patchoat.cc revision f5b0f2cef8554efaa90adc6a1ae04c2b533970ed 
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 "art_field-inl.h"
28#include "art_method-inl.h"
29#include "base/dumpable.h"
30#include "base/scoped_flock.h"
31#include "base/stringpiece.h"
32#include "base/stringprintf.h"
33#include "base/unix_file/fd_file.h"
34#include "base/unix_file/random_access_file_utils.h"
35#include "elf_utils.h"
36#include "elf_file.h"
37#include "elf_file_impl.h"
38#include "gc/space/image_space.h"
39#include "image-inl.h"
40#include "mirror/dex_cache.h"
41#include "mirror/executable.h"
42#include "mirror/object-inl.h"
43#include "mirror/method.h"
44#include "mirror/reference.h"
45#include "noop_compiler_callbacks.h"
46#include "offsets.h"
47#include "os.h"
48#include "runtime.h"
49#include "scoped_thread_state_change-inl.h"
50#include "thread.h"
51#include "utils.h"
52
53namespace art {
54
55static bool LocationToFilename(const std::string& location, InstructionSet isa,
56                               std::string* filename) {
57  bool has_system = false;
58  bool has_cache = false;
59  // image_location = /system/framework/boot.art
60  // system_image_filename = /system/framework/<image_isa>/boot.art
61  std::string system_filename(GetSystemImageFilename(location.c_str(), isa));
62  if (OS::FileExists(system_filename.c_str())) {
63    has_system = true;
64  }
65
66  bool have_android_data = false;
67  bool dalvik_cache_exists = false;
68  bool is_global_cache = false;
69  std::string dalvik_cache;
70  GetDalvikCache(GetInstructionSetString(isa), false, &dalvik_cache,
71                 &have_android_data, &dalvik_cache_exists, &is_global_cache);
72
73  std::string cache_filename;
74  if (have_android_data && dalvik_cache_exists) {
75    // Always set output location even if it does not exist,
76    // so that the caller knows where to create the image.
77    //
78    // image_location = /system/framework/boot.art
79    // *image_filename = /data/dalvik-cache/<image_isa>/boot.art
80    std::string error_msg;
81    if (GetDalvikCacheFilename(location.c_str(), dalvik_cache.c_str(),
82                               &cache_filename, &error_msg)) {
83      has_cache = true;
84    }
85  }
86  if (has_system) {
87    *filename = system_filename;
88    return true;
89  } else if (has_cache) {
90    *filename = cache_filename;
91    return true;
92  } else {
93    return false;
94  }
95}
96
97static const OatHeader* GetOatHeader(const ElfFile* elf_file) {
98  uint64_t off = 0;
99  if (!elf_file->GetSectionOffsetAndSize(".rodata", &off, nullptr)) {
100    return nullptr;
101  }
102
103  OatHeader* oat_header = reinterpret_cast<OatHeader*>(elf_file->Begin() + off);
104  return oat_header;
105}
106
107// This function takes an elf file and reads the current patch delta value
108// encoded in its oat header value
109static bool ReadOatPatchDelta(const ElfFile* elf_file, off_t* delta, std::string* error_msg) {
110  const OatHeader* oat_header = GetOatHeader(elf_file);
111  if (oat_header == nullptr) {
112    *error_msg = "Unable to get oat header from elf file.";
113    return false;
114  }
115  if (!oat_header->IsValid()) {
116    *error_msg = "Elf file has an invalid oat header";
117    return false;
118  }
119  *delta = oat_header->GetImagePatchDelta();
120  return true;
121}
122
123static File* CreateOrOpen(const char* name, bool* created) {
124  if (OS::FileExists(name)) {
125    *created = false;
126    return OS::OpenFileReadWrite(name);
127  } else {
128    *created = true;
129    std::unique_ptr<File> f(OS::CreateEmptyFile(name));
130    if (f.get() != nullptr) {
131      if (fchmod(f->Fd(), 0644) != 0) {
132        PLOG(ERROR) << "Unable to make " << name << " world readable";
133        unlink(name);
134        return nullptr;
135      }
136    }
137    return f.release();
138  }
139}
140
141// Either try to close the file (close=true), or erase it.
142static bool FinishFile(File* file, bool close) {
143  if (close) {
144    if (file->FlushCloseOrErase() != 0) {
145      PLOG(ERROR) << "Failed to flush and close file.";
146      return false;
147    }
148    return true;
149  } else {
150    file->Erase();
151    return false;
152  }
153}
154
155static bool SymlinkFile(const std::string& input_filename, const std::string& output_filename) {
156  if (input_filename == output_filename) {
157    // Input and output are the same, nothing to do.
158    return true;
159  }
160
161  // Unlink the original filename, since we are overwriting it.
162  unlink(output_filename.c_str());
163
164  // Create a symlink from the source file to the target path.
165  if (symlink(input_filename.c_str(), output_filename.c_str()) < 0) {
166    PLOG(ERROR) << "Failed to create symlink " << output_filename << " -> " << input_filename;
167    return false;
168  }
169
170  if (kIsDebugBuild) {
171    LOG(INFO) << "Created symlink " << output_filename << " -> " << input_filename;
172  }
173
174  return true;
175}
176
177bool PatchOat::Patch(const std::string& image_location,
178                     off_t delta,
179                     const std::string& output_directory,
180                     InstructionSet isa,
181                     TimingLogger* timings) {
182  CHECK(Runtime::Current() == nullptr);
183  CHECK(!image_location.empty()) << "image file must have a filename.";
184
185  TimingLogger::ScopedTiming t("Runtime Setup", timings);
186
187  CHECK_NE(isa, kNone);
188  const char* isa_name = GetInstructionSetString(isa);
189
190  // Set up the runtime
191  RuntimeOptions options;
192  NoopCompilerCallbacks callbacks;
193  options.push_back(std::make_pair("compilercallbacks", &callbacks));
194  std::string img = "-Ximage:" + image_location;
195  options.push_back(std::make_pair(img.c_str(), nullptr));
196  options.push_back(std::make_pair("imageinstructionset", reinterpret_cast<const void*>(isa_name)));
197  options.push_back(std::make_pair("-Xno-sig-chain", nullptr));
198  if (!Runtime::Create(options, false)) {
199    LOG(ERROR) << "Unable to initialize runtime";
200    return false;
201  }
202  // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
203  // give it away now and then switch to a more manageable ScopedObjectAccess.
204  Thread::Current()->TransitionFromRunnableToSuspended(kNative);
205  ScopedObjectAccess soa(Thread::Current());
206
207  t.NewTiming("Image and oat Patching setup");
208  std::vector<gc::space::ImageSpace*> spaces = Runtime::Current()->GetHeap()->GetBootImageSpaces();
209  std::map<gc::space::ImageSpace*, std::unique_ptr<File>> space_to_file_map;
210  std::map<gc::space::ImageSpace*, std::unique_ptr<MemMap>> space_to_memmap_map;
211  std::map<gc::space::ImageSpace*, PatchOat> space_to_patchoat_map;
212  std::map<gc::space::ImageSpace*, bool> space_to_skip_patching_map;
213
214  for (size_t i = 0; i < spaces.size(); ++i) {
215    gc::space::ImageSpace* space = spaces[i];
216    std::string input_image_filename = space->GetImageFilename();
217    std::unique_ptr<File> input_image(OS::OpenFileForReading(input_image_filename.c_str()));
218    if (input_image.get() == nullptr) {
219      LOG(ERROR) << "Unable to open input image file at " << input_image_filename;
220      return false;
221    }
222
223    int64_t image_len = input_image->GetLength();
224    if (image_len < 0) {
225      LOG(ERROR) << "Error while getting image length";
226      return false;
227    }
228    ImageHeader image_header;
229    if (sizeof(image_header) != input_image->Read(reinterpret_cast<char*>(&image_header),
230                                                  sizeof(image_header), 0)) {
231      LOG(ERROR) << "Unable to read image header from image file " << input_image->GetPath();
232    }
233
234    /*bool is_image_pic = */IsImagePic(image_header, input_image->GetPath());
235    // Nothing special to do right now since the image always needs to get patched.
236    // Perhaps in some far-off future we may have images with relative addresses that are true-PIC.
237
238    // Create the map where we will write the image patches to.
239    std::string error_msg;
240    std::unique_ptr<MemMap> image(MemMap::MapFile(image_len,
241                                                  PROT_READ | PROT_WRITE,
242                                                  MAP_PRIVATE,
243                                                  input_image->Fd(),
244                                                  0,
245                                                  /*low_4gb*/false,
246                                                  input_image->GetPath().c_str(),
247                                                  &error_msg));
248    if (image.get() == nullptr) {
249      LOG(ERROR) << "Unable to map image file " << input_image->GetPath() << " : " << error_msg;
250      return false;
251    }
252    space_to_file_map.emplace(space, std::move(input_image));
253    space_to_memmap_map.emplace(space, std::move(image));
254  }
255
256  // Do a first pass over the image spaces. Symlink PIC oat and vdex files, and
257  // prepare PatchOat instances for the rest.
258  for (size_t i = 0; i < spaces.size(); ++i) {
259    gc::space::ImageSpace* space = spaces[i];
260    std::string input_image_filename = space->GetImageFilename();
261    std::string input_vdex_filename =
262        ImageHeader::GetVdexLocationFromImageLocation(input_image_filename);
263    std::string input_oat_filename =
264        ImageHeader::GetOatLocationFromImageLocation(input_image_filename);
265    std::unique_ptr<File> input_oat_file(OS::OpenFileForReading(input_oat_filename.c_str()));
266    if (input_oat_file.get() == nullptr) {
267      LOG(ERROR) << "Unable to open input oat file at " << input_oat_filename;
268      return false;
269    }
270    std::string error_msg;
271    std::unique_ptr<ElfFile> elf(ElfFile::Open(input_oat_file.get(),
272                                               PROT_READ | PROT_WRITE, MAP_PRIVATE, &error_msg));
273    if (elf.get() == nullptr) {
274      LOG(ERROR) << "Unable to open oat file " << input_oat_file->GetPath() << " : " << error_msg;
275      return false;
276    }
277
278    bool skip_patching_oat = false;
279    MaybePic is_oat_pic = IsOatPic(elf.get());
280    if (is_oat_pic >= ERROR_FIRST) {
281      // Error logged by IsOatPic
282      return false;
283    } else if (is_oat_pic == PIC) {
284      // Do not need to do ELF-file patching. Create a symlink and skip the ELF patching.
285
286      std::string converted_image_filename = space->GetImageLocation();
287      std::replace(converted_image_filename.begin() + 1, converted_image_filename.end(), '/', '@');
288      std::string output_image_filename = output_directory +
289                                          (StartsWith(converted_image_filename, "/") ? "" : "/") +
290                                          converted_image_filename;
291      std::string output_vdex_filename =
292          ImageHeader::GetVdexLocationFromImageLocation(output_image_filename);
293      std::string output_oat_filename =
294          ImageHeader::GetOatLocationFromImageLocation(output_image_filename);
295
296      if (!ReplaceOatFileWithSymlink(input_oat_file->GetPath(),
297                                     output_oat_filename,
298                                     false,
299                                     true) ||
300          !SymlinkFile(input_vdex_filename, output_vdex_filename)) {
301        // Errors already logged by above call.
302        return false;
303      }
304      // Don't patch the OAT, since we just symlinked it. Image still needs patching.
305      skip_patching_oat = true;
306    } else {
307      CHECK(is_oat_pic == NOT_PIC);
308    }
309
310    PatchOat& p = space_to_patchoat_map.emplace(space,
311                                                PatchOat(
312                                                    isa,
313                                                    elf.release(),
314                                                    space_to_memmap_map.find(space)->second.get(),
315                                                    space->GetLiveBitmap(),
316                                                    space->GetMemMap(),
317                                                    delta,
318                                                    &space_to_memmap_map,
319                                                    timings)).first->second;
320
321    t.NewTiming("Patching files");
322    if (!skip_patching_oat && !p.PatchElf()) {
323      LOG(ERROR) << "Failed to patch oat file " << input_oat_file->GetPath();
324      return false;
325    }
326    if (!p.PatchImage(i == 0)) {
327      LOG(ERROR) << "Failed to patch image file " << input_image_filename;
328      return false;
329    }
330
331    space_to_skip_patching_map.emplace(space, skip_patching_oat);
332  }
333
334  // Do a second pass over the image spaces. Patch image files, non-PIC oat files
335  // and symlink their corresponding vdex files.
336  for (size_t i = 0; i < spaces.size(); ++i) {
337    gc::space::ImageSpace* space = spaces[i];
338    std::string input_image_filename = space->GetImageFilename();
339    std::string input_vdex_filename =
340        ImageHeader::GetVdexLocationFromImageLocation(input_image_filename);
341
342    t.NewTiming("Writing files");
343    std::string converted_image_filename = space->GetImageLocation();
344    std::replace(converted_image_filename.begin() + 1, converted_image_filename.end(), '/', '@');
345    std::string output_image_filename = output_directory +
346                                        (StartsWith(converted_image_filename, "/") ? "" : "/") +
347                                        converted_image_filename;
348    bool new_oat_out;
349    std::unique_ptr<File>
350        output_image_file(CreateOrOpen(output_image_filename.c_str(), &new_oat_out));
351    if (output_image_file.get() == nullptr) {
352      LOG(ERROR) << "Failed to open output image file at " << output_image_filename;
353      return false;
354    }
355
356    PatchOat& p = space_to_patchoat_map.find(space)->second;
357
358    bool success = p.WriteImage(output_image_file.get());
359    success = FinishFile(output_image_file.get(), success);
360    if (!success) {
361      return false;
362    }
363
364    bool skip_patching_oat = space_to_skip_patching_map.find(space)->second;
365    if (!skip_patching_oat) {
366      std::string output_vdex_filename =
367          ImageHeader::GetVdexLocationFromImageLocation(output_image_filename);
368      std::string output_oat_filename =
369          ImageHeader::GetOatLocationFromImageLocation(output_image_filename);
370
371      std::unique_ptr<File>
372          output_oat_file(CreateOrOpen(output_oat_filename.c_str(), &new_oat_out));
373      if (output_oat_file.get() == nullptr) {
374        LOG(ERROR) << "Failed to open output oat file at " << output_oat_filename;
375        return false;
376      }
377      success = p.WriteElf(output_oat_file.get());
378      success = FinishFile(output_oat_file.get(), success);
379      if (success) {
380        success = SymlinkFile(input_vdex_filename, output_vdex_filename);
381      }
382      if (!success) {
383        return false;
384      }
385    }
386  }
387  return true;
388}
389
390bool PatchOat::WriteElf(File* out) {
391  TimingLogger::ScopedTiming t("Writing Elf File", timings_);
392
393  CHECK(oat_file_.get() != nullptr);
394  CHECK(out != nullptr);
395  size_t expect = oat_file_->Size();
396  if (out->WriteFully(reinterpret_cast<char*>(oat_file_->Begin()), expect) &&
397      out->SetLength(expect) == 0) {
398    return true;
399  } else {
400    LOG(ERROR) << "Writing to oat file " << out->GetPath() << " failed.";
401    return false;
402  }
403}
404
405bool PatchOat::WriteImage(File* out) {
406  TimingLogger::ScopedTiming t("Writing image File", timings_);
407  std::string error_msg;
408
409  ScopedFlock img_flock;
410  img_flock.Init(out, &error_msg);
411
412  CHECK(image_ != nullptr);
413  CHECK(out != nullptr);
414  size_t expect = image_->Size();
415  if (out->WriteFully(reinterpret_cast<char*>(image_->Begin()), expect) &&
416      out->SetLength(expect) == 0) {
417    return true;
418  } else {
419    LOG(ERROR) << "Writing to image file " << out->GetPath() << " failed.";
420    return false;
421  }
422}
423
424bool PatchOat::IsImagePic(const ImageHeader& image_header, const std::string& image_path) {
425  if (!image_header.CompilePic()) {
426    if (kIsDebugBuild) {
427      LOG(INFO) << "image at location " << image_path << " was *not* compiled pic";
428    }
429    return false;
430  }
431
432  if (kIsDebugBuild) {
433    LOG(INFO) << "image at location " << image_path << " was compiled PIC";
434  }
435
436  return true;
437}
438
439PatchOat::MaybePic PatchOat::IsOatPic(const ElfFile* oat_in) {
440  if (oat_in == nullptr) {
441    LOG(ERROR) << "No ELF input oat fie available";
442    return ERROR_OAT_FILE;
443  }
444
445  const std::string& file_path = oat_in->GetFilePath();
446
447  const OatHeader* oat_header = GetOatHeader(oat_in);
448  if (oat_header == nullptr) {
449    LOG(ERROR) << "Failed to find oat header in oat file " << file_path;
450    return ERROR_OAT_FILE;
451  }
452
453  if (!oat_header->IsValid()) {
454    LOG(ERROR) << "Elf file " << file_path << " has an invalid oat header";
455    return ERROR_OAT_FILE;
456  }
457
458  bool is_pic = oat_header->IsPic();
459  if (kIsDebugBuild) {
460    LOG(INFO) << "Oat file at " << file_path << " is " << (is_pic ? "PIC" : "not pic");
461  }
462
463  return is_pic ? PIC : NOT_PIC;
464}
465
466bool PatchOat::ReplaceOatFileWithSymlink(const std::string& input_oat_filename,
467                                         const std::string& output_oat_filename,
468                                         bool output_oat_opened_from_fd,
469                                         bool new_oat_out) {
470  // Need a file when we are PIC, since we symlink over it. Refusing to symlink into FD.
471  if (output_oat_opened_from_fd) {
472    // TODO: installd uses --output-oat-fd. Should we change class linking logic for PIC?
473    LOG(ERROR) << "No output oat filename specified, needs filename for when we are PIC";
474    return false;
475  }
476
477  // Image was PIC. Create symlink where the oat is supposed to go.
478  if (!new_oat_out) {
479    LOG(ERROR) << "Oat file " << output_oat_filename << " already exists, refusing to overwrite";
480    return false;
481  }
482
483  // Delete the original file, since we won't need it.
484  unlink(output_oat_filename.c_str());
485
486  // Create a symlink from the old oat to the new oat
487  if (symlink(input_oat_filename.c_str(), output_oat_filename.c_str()) < 0) {
488    int err = errno;
489    LOG(ERROR) << "Failed to create symlink at " << output_oat_filename
490               << " error(" << err << "): " << strerror(err);
491    return false;
492  }
493
494  if (kIsDebugBuild) {
495    LOG(INFO) << "Created symlink " << output_oat_filename << " -> " << input_oat_filename;
496  }
497
498  return true;
499}
500
501class PatchOatArtFieldVisitor : public ArtFieldVisitor {
502 public:
503  explicit PatchOatArtFieldVisitor(PatchOat* patch_oat) : patch_oat_(patch_oat) {}
504
505  void Visit(ArtField* field) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
506    ArtField* const dest = patch_oat_->RelocatedCopyOf(field);
507    dest->SetDeclaringClass(
508        patch_oat_->RelocatedAddressOfPointer(field->GetDeclaringClass().Ptr()));
509  }
510
511 private:
512  PatchOat* const patch_oat_;
513};
514
515void PatchOat::PatchArtFields(const ImageHeader* image_header) {
516  PatchOatArtFieldVisitor visitor(this);
517  image_header->VisitPackedArtFields(&visitor, heap_->Begin());
518}
519
520class PatchOatArtMethodVisitor : public ArtMethodVisitor {
521 public:
522  explicit PatchOatArtMethodVisitor(PatchOat* patch_oat) : patch_oat_(patch_oat) {}
523
524  void Visit(ArtMethod* method) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
525    ArtMethod* const dest = patch_oat_->RelocatedCopyOf(method);
526    patch_oat_->FixupMethod(method, dest);
527  }
528
529 private:
530  PatchOat* const patch_oat_;
531};
532
533void PatchOat::PatchArtMethods(const ImageHeader* image_header) {
534  const PointerSize pointer_size = InstructionSetPointerSize(isa_);
535  PatchOatArtMethodVisitor visitor(this);
536  image_header->VisitPackedArtMethods(&visitor, heap_->Begin(), pointer_size);
537}
538
539void PatchOat::PatchImTables(const ImageHeader* image_header) {
540  const PointerSize pointer_size = InstructionSetPointerSize(isa_);
541  // We can safely walk target image since the conflict tables are independent.
542  image_header->VisitPackedImTables(
543      [this](ArtMethod* method) {
544        return RelocatedAddressOfPointer(method);
545      },
546      image_->Begin(),
547      pointer_size);
548}
549
550void PatchOat::PatchImtConflictTables(const ImageHeader* image_header) {
551  const PointerSize pointer_size = InstructionSetPointerSize(isa_);
552  // We can safely walk target image since the conflict tables are independent.
553  image_header->VisitPackedImtConflictTables(
554      [this](ArtMethod* method) {
555        return RelocatedAddressOfPointer(method);
556      },
557      image_->Begin(),
558      pointer_size);
559}
560
561class FixupRootVisitor : public RootVisitor {
562 public:
563  explicit FixupRootVisitor(const PatchOat* patch_oat) : patch_oat_(patch_oat) {
564  }
565
566  void VisitRoots(mirror::Object*** roots, size_t count, const RootInfo& info ATTRIBUTE_UNUSED)
567      OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
568    for (size_t i = 0; i < count; ++i) {
569      *roots[i] = patch_oat_->RelocatedAddressOfPointer(*roots[i]);
570    }
571  }
572
573  void VisitRoots(mirror::CompressedReference<mirror::Object>** roots, size_t count,
574                  const RootInfo& info ATTRIBUTE_UNUSED)
575      OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
576    for (size_t i = 0; i < count; ++i) {
577      roots[i]->Assign(patch_oat_->RelocatedAddressOfPointer(roots[i]->AsMirrorPtr()));
578    }
579  }
580
581 private:
582  const PatchOat* const patch_oat_;
583};
584
585void PatchOat::PatchInternedStrings(const ImageHeader* image_header) {
586  const auto& section = image_header->GetImageSection(ImageHeader::kSectionInternedStrings);
587  InternTable temp_table;
588  // Note that we require that ReadFromMemory does not make an internal copy of the elements.
589  // This also relies on visit roots not doing any verification which could fail after we update
590  // the roots to be the image addresses.
591  temp_table.AddTableFromMemory(image_->Begin() + section.Offset());
592  FixupRootVisitor visitor(this);
593  temp_table.VisitRoots(&visitor, kVisitRootFlagAllRoots);
594}
595
596void PatchOat::PatchClassTable(const ImageHeader* image_header) {
597  const auto& section = image_header->GetImageSection(ImageHeader::kSectionClassTable);
598  if (section.Size() == 0) {
599    return;
600  }
601  // Note that we require that ReadFromMemory does not make an internal copy of the elements.
602  // This also relies on visit roots not doing any verification which could fail after we update
603  // the roots to be the image addresses.
604  WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
605  ClassTable temp_table;
606  temp_table.ReadFromMemory(image_->Begin() + section.Offset());
607  FixupRootVisitor visitor(this);
608  BufferedRootVisitor<kDefaultBufferedRootCount> buffered_visitor(&visitor, RootInfo(kRootUnknown));
609  temp_table.VisitRoots(buffered_visitor);
610}
611
612
613class RelocatedPointerVisitor {
614 public:
615  explicit RelocatedPointerVisitor(PatchOat* patch_oat) : patch_oat_(patch_oat) {}
616
617  template <typename T>
618  T* operator()(T* ptr) const {
619    return patch_oat_->RelocatedAddressOfPointer(ptr);
620  }
621
622 private:
623  PatchOat* const patch_oat_;
624};
625
626void PatchOat::PatchDexFileArrays(mirror::ObjectArray<mirror::Object>* img_roots) {
627  auto* dex_caches = down_cast<mirror::ObjectArray<mirror::DexCache>*>(
628      img_roots->Get(ImageHeader::kDexCaches));
629  const PointerSize pointer_size = InstructionSetPointerSize(isa_);
630  for (size_t i = 0, count = dex_caches->GetLength(); i < count; ++i) {
631    auto* orig_dex_cache = dex_caches->GetWithoutChecks(i);
632    auto* copy_dex_cache = RelocatedCopyOf(orig_dex_cache);
633    // Though the DexCache array fields are usually treated as native pointers, we set the full
634    // 64-bit values here, clearing the top 32 bits for 32-bit targets. The zero-extension is
635    // done by casting to the unsigned type uintptr_t before casting to int64_t, i.e.
636    //     static_cast<int64_t>(reinterpret_cast<uintptr_t>(image_begin_ + offset))).
637    mirror::StringDexCacheType* orig_strings = orig_dex_cache->GetStrings();
638    mirror::StringDexCacheType* relocated_strings = RelocatedAddressOfPointer(orig_strings);
639    copy_dex_cache->SetField64<false>(
640        mirror::DexCache::StringsOffset(),
641        static_cast<int64_t>(reinterpret_cast<uintptr_t>(relocated_strings)));
642    if (orig_strings != nullptr) {
643      orig_dex_cache->FixupStrings(RelocatedCopyOf(orig_strings), RelocatedPointerVisitor(this));
644    }
645    GcRoot<mirror::Class>* orig_types = orig_dex_cache->GetResolvedTypes();
646    GcRoot<mirror::Class>* relocated_types = RelocatedAddressOfPointer(orig_types);
647    copy_dex_cache->SetField64<false>(
648        mirror::DexCache::ResolvedTypesOffset(),
649        static_cast<int64_t>(reinterpret_cast<uintptr_t>(relocated_types)));
650    if (orig_types != nullptr) {
651      orig_dex_cache->FixupResolvedTypes(RelocatedCopyOf(orig_types),
652                                         RelocatedPointerVisitor(this));
653    }
654    ArtMethod** orig_methods = orig_dex_cache->GetResolvedMethods();
655    ArtMethod** relocated_methods = RelocatedAddressOfPointer(orig_methods);
656    copy_dex_cache->SetField64<false>(
657        mirror::DexCache::ResolvedMethodsOffset(),
658        static_cast<int64_t>(reinterpret_cast<uintptr_t>(relocated_methods)));
659    if (orig_methods != nullptr) {
660      ArtMethod** copy_methods = RelocatedCopyOf(orig_methods);
661      for (size_t j = 0, num = orig_dex_cache->NumResolvedMethods(); j != num; ++j) {
662        ArtMethod* orig = mirror::DexCache::GetElementPtrSize(orig_methods, j, pointer_size);
663        ArtMethod* copy = RelocatedAddressOfPointer(orig);
664        mirror::DexCache::SetElementPtrSize(copy_methods, j, copy, pointer_size);
665      }
666    }
667    ArtField** orig_fields = orig_dex_cache->GetResolvedFields();
668    ArtField** relocated_fields = RelocatedAddressOfPointer(orig_fields);
669    copy_dex_cache->SetField64<false>(
670        mirror::DexCache::ResolvedFieldsOffset(),
671        static_cast<int64_t>(reinterpret_cast<uintptr_t>(relocated_fields)));
672    if (orig_fields != nullptr) {
673      ArtField** copy_fields = RelocatedCopyOf(orig_fields);
674      for (size_t j = 0, num = orig_dex_cache->NumResolvedFields(); j != num; ++j) {
675        ArtField* orig = mirror::DexCache::GetElementPtrSize(orig_fields, j, pointer_size);
676        ArtField* copy = RelocatedAddressOfPointer(orig);
677        mirror::DexCache::SetElementPtrSize(copy_fields, j, copy, pointer_size);
678      }
679    }
680  }
681}
682
683bool PatchOat::PatchImage(bool primary_image) {
684  ImageHeader* image_header = reinterpret_cast<ImageHeader*>(image_->Begin());
685  CHECK_GT(image_->Size(), sizeof(ImageHeader));
686  // These are the roots from the original file.
687  auto* img_roots = image_header->GetImageRoots();
688  image_header->RelocateImage(delta_);
689
690  PatchArtFields(image_header);
691  PatchArtMethods(image_header);
692  PatchImTables(image_header);
693  PatchImtConflictTables(image_header);
694  PatchInternedStrings(image_header);
695  PatchClassTable(image_header);
696  // Patch dex file int/long arrays which point to ArtFields.
697  PatchDexFileArrays(img_roots);
698
699  if (primary_image) {
700    VisitObject(img_roots);
701  }
702
703  if (!image_header->IsValid()) {
704    LOG(ERROR) << "relocation renders image header invalid";
705    return false;
706  }
707
708  {
709    TimingLogger::ScopedTiming t("Walk Bitmap", timings_);
710    // Walk the bitmap.
711    WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
712    bitmap_->Walk(PatchOat::BitmapCallback, this);
713  }
714  return true;
715}
716
717
718void PatchOat::PatchVisitor::operator() (mirror::Object* obj, MemberOffset off,
719                                         bool is_static_unused ATTRIBUTE_UNUSED) const {
720  mirror::Object* referent = obj->GetFieldObject<mirror::Object, kVerifyNone>(off);
721  mirror::Object* moved_object = patcher_->RelocatedAddressOfPointer(referent);
722  copy_->SetFieldObjectWithoutWriteBarrier<false, true, kVerifyNone>(off, moved_object);
723}
724
725void PatchOat::PatchVisitor::operator() (mirror::Class* cls ATTRIBUTE_UNUSED,
726                                         mirror::Reference* ref) const {
727  MemberOffset off = mirror::Reference::ReferentOffset();
728  mirror::Object* referent = ref->GetReferent();
729  DCHECK(referent == nullptr ||
730         Runtime::Current()->GetHeap()->ObjectIsInBootImageSpace(referent)) << referent;
731  mirror::Object* moved_object = patcher_->RelocatedAddressOfPointer(referent);
732  copy_->SetFieldObjectWithoutWriteBarrier<false, true, kVerifyNone>(off, moved_object);
733}
734
735// Called by BitmapCallback
736void PatchOat::VisitObject(mirror::Object* object) {
737  mirror::Object* copy = RelocatedCopyOf(object);
738  CHECK(copy != nullptr);
739  if (kUseBakerOrBrooksReadBarrier) {
740    object->AssertReadBarrierPointer();
741    if (kUseBrooksReadBarrier) {
742      mirror::Object* moved_to = RelocatedAddressOfPointer(object);
743      copy->SetReadBarrierPointer(moved_to);
744      DCHECK_EQ(copy->GetReadBarrierPointer(), moved_to);
745    }
746  }
747  PatchOat::PatchVisitor visitor(this, copy);
748  object->VisitReferences<kVerifyNone>(visitor, visitor);
749  if (object->IsClass<kVerifyNone>()) {
750    const PointerSize pointer_size = InstructionSetPointerSize(isa_);
751    mirror::Class* klass = object->AsClass();
752    mirror::Class* copy_klass = down_cast<mirror::Class*>(copy);
753    RelocatedPointerVisitor native_visitor(this);
754    klass->FixupNativePointers(copy_klass, pointer_size, native_visitor);
755    auto* vtable = klass->GetVTable();
756    if (vtable != nullptr) {
757      vtable->Fixup(RelocatedCopyOfFollowImages(vtable), pointer_size, native_visitor);
758    }
759    auto* iftable = klass->GetIfTable();
760    if (iftable != nullptr) {
761      for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
762        if (iftable->GetMethodArrayCount(i) > 0) {
763          auto* method_array = iftable->GetMethodArray(i);
764          CHECK(method_array != nullptr);
765          method_array->Fixup(RelocatedCopyOfFollowImages(method_array),
766                              pointer_size,
767                              native_visitor);
768        }
769      }
770    }
771  } else if (object->GetClass() == mirror::Method::StaticClass() ||
772             object->GetClass() == mirror::Constructor::StaticClass()) {
773    // Need to go update the ArtMethod.
774    auto* dest = down_cast<mirror::Executable*>(copy);
775    auto* src = down_cast<mirror::Executable*>(object);
776    dest->SetArtMethod(RelocatedAddressOfPointer(src->GetArtMethod()));
777  }
778}
779
780void PatchOat::FixupMethod(ArtMethod* object, ArtMethod* copy) {
781  const PointerSize pointer_size = InstructionSetPointerSize(isa_);
782  copy->CopyFrom(object, pointer_size);
783  // Just update the entry points if it looks like we should.
784  // TODO: sanity check all the pointers' values
785  copy->SetDeclaringClass(RelocatedAddressOfPointer(object->GetDeclaringClass()));
786  copy->SetDexCacheResolvedMethods(
787      RelocatedAddressOfPointer(object->GetDexCacheResolvedMethods(pointer_size)), pointer_size);
788  copy->SetDexCacheResolvedTypes(
789      RelocatedAddressOfPointer(object->GetDexCacheResolvedTypes(pointer_size)), pointer_size);
790  copy->SetEntryPointFromQuickCompiledCodePtrSize(RelocatedAddressOfPointer(
791      object->GetEntryPointFromQuickCompiledCodePtrSize(pointer_size)), pointer_size);
792  // No special handling for IMT conflict table since all pointers are moved by the same offset.
793  copy->SetDataPtrSize(RelocatedAddressOfPointer(
794      object->GetDataPtrSize(pointer_size)), pointer_size);
795}
796
797bool PatchOat::Patch(File* input_oat, off_t delta, File* output_oat, TimingLogger* timings,
798                     bool output_oat_opened_from_fd, bool new_oat_out) {
799  CHECK(input_oat != nullptr);
800  CHECK(output_oat != nullptr);
801  CHECK_GE(input_oat->Fd(), 0);
802  CHECK_GE(output_oat->Fd(), 0);
803  TimingLogger::ScopedTiming t("Setup Oat File Patching", timings);
804
805  std::string error_msg;
806  std::unique_ptr<ElfFile> elf(ElfFile::Open(input_oat,
807                                             PROT_READ | PROT_WRITE, MAP_PRIVATE, &error_msg));
808  if (elf.get() == nullptr) {
809    LOG(ERROR) << "unable to open oat file " << input_oat->GetPath() << " : " << error_msg;
810    return false;
811  }
812
813  MaybePic is_oat_pic = IsOatPic(elf.get());
814  if (is_oat_pic >= ERROR_FIRST) {
815    // Error logged by IsOatPic
816    return false;
817  } else if (is_oat_pic == PIC) {
818    // Do not need to do ELF-file patching. Create a symlink and skip the rest.
819    // Any errors will be logged by the function call.
820    return ReplaceOatFileWithSymlink(input_oat->GetPath(),
821                                     output_oat->GetPath(),
822                                     output_oat_opened_from_fd,
823                                     new_oat_out);
824  } else {
825    CHECK(is_oat_pic == NOT_PIC);
826  }
827
828  PatchOat p(elf.release(), delta, timings);
829  t.NewTiming("Patch Oat file");
830  if (!p.PatchElf()) {
831    return false;
832  }
833
834  t.NewTiming("Writing oat file");
835  if (!p.WriteElf(output_oat)) {
836    return false;
837  }
838  return true;
839}
840
841template <typename ElfFileImpl>
842bool PatchOat::PatchOatHeader(ElfFileImpl* oat_file) {
843  auto rodata_sec = oat_file->FindSectionByName(".rodata");
844  if (rodata_sec == nullptr) {
845    return false;
846  }
847  OatHeader* oat_header = reinterpret_cast<OatHeader*>(oat_file->Begin() + rodata_sec->sh_offset);
848  if (!oat_header->IsValid()) {
849    LOG(ERROR) << "Elf file " << oat_file->GetFilePath() << " has an invalid oat header";
850    return false;
851  }
852  oat_header->RelocateOat(delta_);
853  return true;
854}
855
856bool PatchOat::PatchElf() {
857  if (oat_file_->Is64Bit()) {
858    return PatchElf<ElfFileImpl64>(oat_file_->GetImpl64());
859  } else {
860    return PatchElf<ElfFileImpl32>(oat_file_->GetImpl32());
861  }
862}
863
864template <typename ElfFileImpl>
865bool PatchOat::PatchElf(ElfFileImpl* oat_file) {
866  TimingLogger::ScopedTiming t("Fixup Elf Text Section", timings_);
867
868  // Fix up absolute references to locations within the boot image.
869  if (!oat_file->ApplyOatPatchesTo(".text", delta_)) {
870    return false;
871  }
872
873  // Update the OatHeader fields referencing the boot image.
874  if (!PatchOatHeader<ElfFileImpl>(oat_file)) {
875    return false;
876  }
877
878  bool need_boot_oat_fixup = true;
879  for (unsigned int i = 0; i < oat_file->GetProgramHeaderNum(); ++i) {
880    auto hdr = oat_file->GetProgramHeader(i);
881    if (hdr->p_type == PT_LOAD && hdr->p_vaddr == 0u) {
882      need_boot_oat_fixup = false;
883      break;
884    }
885  }
886  if (!need_boot_oat_fixup) {
887    // This is an app oat file that can be loaded at an arbitrary address in memory.
888    // Boot image references were patched above and there's nothing else to do.
889    return true;
890  }
891
892  // This is a boot oat file that's loaded at a particular address and we need
893  // to patch all absolute addresses, starting with ELF program headers.
894
895  t.NewTiming("Fixup Elf Headers");
896  // Fixup Phdr's
897  oat_file->FixupProgramHeaders(delta_);
898
899  t.NewTiming("Fixup Section Headers");
900  // Fixup Shdr's
901  oat_file->FixupSectionHeaders(delta_);
902
903  t.NewTiming("Fixup Dynamics");
904  oat_file->FixupDynamic(delta_);
905
906  t.NewTiming("Fixup Elf Symbols");
907  // Fixup dynsym
908  if (!oat_file->FixupSymbols(delta_, true)) {
909    return false;
910  }
911  // Fixup symtab
912  if (!oat_file->FixupSymbols(delta_, false)) {
913    return false;
914  }
915
916  t.NewTiming("Fixup Debug Sections");
917  if (!oat_file->FixupDebugSections(delta_)) {
918    return false;
919  }
920
921  return true;
922}
923
924static int orig_argc;
925static char** orig_argv;
926
927static std::string CommandLine() {
928  std::vector<std::string> command;
929  for (int i = 0; i < orig_argc; ++i) {
930    command.push_back(orig_argv[i]);
931  }
932  return Join(command, ' ');
933}
934
935static void UsageErrorV(const char* fmt, va_list ap) {
936  std::string error;
937  StringAppendV(&error, fmt, ap);
938  LOG(ERROR) << error;
939}
940
941static void UsageError(const char* fmt, ...) {
942  va_list ap;
943  va_start(ap, fmt);
944  UsageErrorV(fmt, ap);
945  va_end(ap);
946}
947
948NO_RETURN static void Usage(const char *fmt, ...) {
949  va_list ap;
950  va_start(ap, fmt);
951  UsageErrorV(fmt, ap);
952  va_end(ap);
953
954  UsageError("Command: %s", CommandLine().c_str());
955  UsageError("Usage: patchoat [options]...");
956  UsageError("");
957  UsageError("  --instruction-set=<isa>: Specifies the instruction set the patched code is");
958  UsageError("      compiled for. Required if you use --input-oat-location");
959  UsageError("");
960  UsageError("  --input-oat-file=<file.oat>: Specifies the exact filename of the oat file to be");
961  UsageError("      patched.");
962  UsageError("");
963  UsageError("  --input-oat-fd=<file-descriptor>: Specifies the file-descriptor of the oat file");
964  UsageError("      to be patched.");
965  UsageError("");
966  UsageError("  --input-vdex-fd=<file-descriptor>: Specifies the file-descriptor of the vdex file");
967  UsageError("      associated with the oat file.");
968  UsageError("");
969  UsageError("  --input-oat-location=<file.oat>: Specifies the 'location' to read the patched");
970  UsageError("      oat file from. If used one must also supply the --instruction-set");
971  UsageError("");
972  UsageError("  --input-image-location=<file.art>: Specifies the 'location' of the image file to");
973  UsageError("      be patched. If --instruction-set is not given it will use the instruction set");
974  UsageError("      extracted from the --input-oat-file.");
975  UsageError("");
976  UsageError("  --output-oat-file=<file.oat>: Specifies the exact file to write the patched oat");
977  UsageError("      file to.");
978  UsageError("");
979  UsageError("  --output-oat-fd=<file-descriptor>: Specifies the file-descriptor to write the");
980  UsageError("      patched oat file to.");
981  UsageError("");
982  UsageError("  --output-vdex-fd=<file-descriptor>: Specifies the file-descriptor to copy the");
983  UsageError("      the vdex file associated with the patch oat file to.");
984  UsageError("");
985  UsageError("  --output-image-file=<file.art>: Specifies the exact file to write the patched");
986  UsageError("      image file to.");
987  UsageError("");
988  UsageError("  --base-offset-delta=<delta>: Specify the amount to change the old base-offset by.");
989  UsageError("      This value may be negative.");
990  UsageError("");
991  UsageError("  --patched-image-location=<file.art>: Relocate the oat file to be the same as the");
992  UsageError("      image at the given location. If used one must also specify the");
993  UsageError("      --instruction-set flag. It will search for this image in the same way that");
994  UsageError("      is done when loading one.");
995  UsageError("");
996  UsageError("  --lock-output: Obtain a flock on output oat file before starting.");
997  UsageError("");
998  UsageError("  --no-lock-output: Do not attempt to obtain a flock on output oat file.");
999  UsageError("");
1000  UsageError("  --dump-timings: dump out patch timing information");
1001  UsageError("");
1002  UsageError("  --no-dump-timings: do not dump out patch timing information");
1003  UsageError("");
1004
1005  exit(EXIT_FAILURE);
1006}
1007
1008static bool ReadBaseDelta(const char* name, off_t* delta, std::string* error_msg) {
1009  CHECK(name != nullptr);
1010  CHECK(delta != nullptr);
1011  std::unique_ptr<File> file;
1012  if (OS::FileExists(name)) {
1013    file.reset(OS::OpenFileForReading(name));
1014    if (file.get() == nullptr) {
1015      *error_msg = "Failed to open file %s for reading";
1016      return false;
1017    }
1018  } else {
1019    *error_msg = "File %s does not exist";
1020    return false;
1021  }
1022  CHECK(file.get() != nullptr);
1023  ImageHeader hdr;
1024  if (sizeof(hdr) != file->Read(reinterpret_cast<char*>(&hdr), sizeof(hdr), 0)) {
1025    *error_msg = "Failed to read file %s";
1026    return false;
1027  }
1028  if (!hdr.IsValid()) {
1029    *error_msg = "%s does not contain a valid image header.";
1030    return false;
1031  }
1032  *delta = hdr.GetPatchDelta();
1033  return true;
1034}
1035
1036static int patchoat_image(TimingLogger& timings,
1037                          InstructionSet isa,
1038                          const std::string& input_image_location,
1039                          const std::string& output_image_filename,
1040                          off_t base_delta,
1041                          bool base_delta_set,
1042                          bool debug) {
1043  CHECK(!input_image_location.empty());
1044  if (output_image_filename.empty()) {
1045    Usage("Image patching requires --output-image-file");
1046  }
1047
1048  if (!base_delta_set) {
1049    Usage("Must supply a desired new offset or delta.");
1050  }
1051
1052  if (!IsAligned<kPageSize>(base_delta)) {
1053    Usage("Base offset/delta must be aligned to a pagesize (0x%08x) boundary.", kPageSize);
1054  }
1055
1056  if (debug) {
1057    LOG(INFO) << "moving offset by " << base_delta
1058        << " (0x" << std::hex << base_delta << ") bytes or "
1059        << std::dec << (base_delta/kPageSize) << " pages.";
1060  }
1061
1062  TimingLogger::ScopedTiming pt("patch image and oat", &timings);
1063
1064  std::string output_directory =
1065      output_image_filename.substr(0, output_image_filename.find_last_of("/"));
1066  bool ret = PatchOat::Patch(input_image_location, base_delta, output_directory, isa, &timings);
1067
1068  if (kIsDebugBuild) {
1069    LOG(INFO) << "Exiting with return ... " << ret;
1070  }
1071  return ret ? EXIT_SUCCESS : EXIT_FAILURE;
1072}
1073
1074static int patchoat_oat(TimingLogger& timings,
1075                        InstructionSet isa,
1076                        const std::string& patched_image_location,
1077                        off_t base_delta,
1078                        bool base_delta_set,
1079                        int input_oat_fd,
1080                        int input_vdex_fd,
1081                        const std::string& input_oat_location,
1082                        std::string input_oat_filename,
1083                        bool have_input_oat,
1084                        int output_oat_fd,
1085                        int output_vdex_fd,
1086                        std::string output_oat_filename,
1087                        bool have_output_oat,
1088                        bool lock_output,
1089                        bool debug) {
1090  {
1091    // Only 1 of these may be set.
1092    uint32_t cnt = 0;
1093    cnt += (base_delta_set) ? 1 : 0;
1094    cnt += (!patched_image_location.empty()) ? 1 : 0;
1095    if (cnt > 1) {
1096      Usage("Only one of --base-offset-delta or --patched-image-location may be used.");
1097    } else if (cnt == 0) {
1098      Usage("Must specify --base-offset-delta or --patched-image-location.");
1099    }
1100  }
1101
1102  if (!have_input_oat || !have_output_oat) {
1103    Usage("Both input and output oat must be supplied to patch an app odex.");
1104  }
1105
1106  if (!input_oat_location.empty()) {
1107    if (!LocationToFilename(input_oat_location, isa, &input_oat_filename)) {
1108      Usage("Unable to find filename for input oat location %s", input_oat_location.c_str());
1109    }
1110    if (debug) {
1111      LOG(INFO) << "Using input-oat-file " << input_oat_filename;
1112    }
1113  }
1114
1115  if ((input_oat_fd == -1) != (input_vdex_fd == -1)) {
1116    Usage("Either both input oat and vdex have to be passed as file descriptors or none of them");
1117  } else if ((output_oat_fd == -1) != (output_vdex_fd == -1)) {
1118    Usage("Either both output oat and vdex have to be passed as file descriptors or none of them");
1119  }
1120
1121  bool match_delta = false;
1122  if (!patched_image_location.empty()) {
1123    std::string system_filename;
1124    bool has_system = false;
1125    std::string cache_filename;
1126    bool has_cache = false;
1127    bool has_android_data_unused = false;
1128    bool is_global_cache = false;
1129    if (!gc::space::ImageSpace::FindImageFilename(patched_image_location.c_str(), isa,
1130                                                  &system_filename, &has_system, &cache_filename,
1131                                                  &has_android_data_unused, &has_cache,
1132                                                  &is_global_cache)) {
1133      Usage("Unable to determine image file for location %s", patched_image_location.c_str());
1134    }
1135    std::string patched_image_filename;
1136    if (has_cache) {
1137      patched_image_filename = cache_filename;
1138    } else if (has_system) {
1139      LOG(WARNING) << "Only image file found was in /system for image location "
1140          << patched_image_location;
1141      patched_image_filename = system_filename;
1142    } else {
1143      Usage("Unable to determine image file for location %s", patched_image_location.c_str());
1144    }
1145    if (debug) {
1146      LOG(INFO) << "Using patched-image-file " << patched_image_filename;
1147    }
1148
1149    base_delta_set = true;
1150    match_delta = true;
1151    std::string error_msg;
1152    if (!ReadBaseDelta(patched_image_filename.c_str(), &base_delta, &error_msg)) {
1153      Usage(error_msg.c_str(), patched_image_filename.c_str());
1154    }
1155  }
1156
1157  if (!IsAligned<kPageSize>(base_delta)) {
1158    Usage("Base offset/delta must be alligned to a pagesize (0x%08x) boundary.", kPageSize);
1159  }
1160
1161  // We can symlink VDEX only if we have both input and output specified as filenames.
1162  // Store that piece of information before we possibly create bogus filenames for
1163  // files passed as file descriptors.
1164  bool symlink_vdex = !input_oat_filename.empty() && !output_oat_filename.empty();
1165
1166  // Infer names of VDEX files.
1167  std::string input_vdex_filename;
1168  std::string output_vdex_filename;
1169  if (!input_oat_filename.empty()) {
1170    input_vdex_filename = ReplaceFileExtension(input_oat_filename, "vdex");
1171  }
1172  if (!output_oat_filename.empty()) {
1173    output_vdex_filename = ReplaceFileExtension(output_oat_filename, "vdex");
1174  }
1175
1176  // Do we need to cleanup output files if we fail?
1177  bool new_oat_out = false;
1178  bool new_vdex_out = false;
1179
1180  std::unique_ptr<File> input_oat;
1181  std::unique_ptr<File> output_oat;
1182
1183  if (input_oat_fd != -1) {
1184    if (input_oat_filename.empty()) {
1185      input_oat_filename = "input-oat-file";
1186    }
1187    input_oat.reset(new File(input_oat_fd, input_oat_filename, false));
1188    if (input_oat_fd == output_oat_fd) {
1189      input_oat.get()->DisableAutoClose();
1190    }
1191    if (input_oat == nullptr) {
1192      // Unlikely, but ensure exhaustive logging in non-0 exit code case
1193      LOG(ERROR) << "Failed to open input oat file by its FD" << input_oat_fd;
1194      return EXIT_FAILURE;
1195    }
1196  } else {
1197    CHECK(!input_oat_filename.empty());
1198    input_oat.reset(OS::OpenFileForReading(input_oat_filename.c_str()));
1199    if (input_oat == nullptr) {
1200      int err = errno;
1201      LOG(ERROR) << "Failed to open input oat file " << input_oat_filename
1202          << ": " << strerror(err) << "(" << err << ")";
1203      return EXIT_FAILURE;
1204    }
1205  }
1206
1207  std::string error_msg;
1208  std::unique_ptr<ElfFile> elf(ElfFile::Open(input_oat.get(), PROT_READ, MAP_PRIVATE, &error_msg));
1209  if (elf.get() == nullptr) {
1210    LOG(ERROR) << "unable to open oat file " << input_oat->GetPath() << " : " << error_msg;
1211    return EXIT_FAILURE;
1212  }
1213  if (!elf->HasSection(".text.oat_patches")) {
1214    LOG(ERROR) << "missing oat patch section in input oat file " << input_oat->GetPath();
1215    return EXIT_FAILURE;
1216  }
1217
1218  if (output_oat_fd != -1) {
1219    if (output_oat_filename.empty()) {
1220      output_oat_filename = "output-oat-file";
1221    }
1222    output_oat.reset(new File(output_oat_fd, output_oat_filename, true));
1223    if (output_oat == nullptr) {
1224      // Unlikely, but ensure exhaustive logging in non-0 exit code case
1225      LOG(ERROR) << "Failed to open output oat file by its FD" << output_oat_fd;
1226    }
1227  } else {
1228    CHECK(!output_oat_filename.empty());
1229    output_oat.reset(CreateOrOpen(output_oat_filename.c_str(), &new_oat_out));
1230    if (output_oat == nullptr) {
1231      int err = errno;
1232      LOG(ERROR) << "Failed to open output oat file " << output_oat_filename
1233          << ": " << strerror(err) << "(" << err << ")";
1234    }
1235  }
1236
1237  // Open VDEX files if we are not symlinking them.
1238  std::unique_ptr<File> input_vdex;
1239  std::unique_ptr<File> output_vdex;
1240  if (symlink_vdex) {
1241    new_vdex_out = !OS::FileExists(output_vdex_filename.c_str());
1242  } else {
1243    if (input_vdex_fd != -1) {
1244      input_vdex.reset(new File(input_vdex_fd, input_vdex_filename, true));
1245      if (input_vdex == nullptr) {
1246        // Unlikely, but ensure exhaustive logging in non-0 exit code case
1247        LOG(ERROR) << "Failed to open input vdex file by its FD" << input_vdex_fd;
1248      }
1249    } else {
1250      input_vdex.reset(OS::OpenFileForReading(input_vdex_filename.c_str()));
1251      if (input_vdex == nullptr) {
1252        PLOG(ERROR) << "Failed to open input vdex file " << input_vdex_filename;
1253        return EXIT_FAILURE;
1254      }
1255    }
1256    if (output_vdex_fd != -1) {
1257      output_vdex.reset(new File(output_vdex_fd, output_vdex_filename, true));
1258      if (output_vdex == nullptr) {
1259        // Unlikely, but ensure exhaustive logging in non-0 exit code case
1260        LOG(ERROR) << "Failed to open output vdex file by its FD" << output_vdex_fd;
1261      }
1262    } else {
1263      output_vdex.reset(CreateOrOpen(output_vdex_filename.c_str(), &new_vdex_out));
1264      if (output_vdex == nullptr) {
1265        PLOG(ERROR) << "Failed to open output vdex file " << output_vdex_filename;
1266        return EXIT_FAILURE;
1267      }
1268    }
1269  }
1270
1271  // TODO: get rid of this.
1272  auto cleanup = [&output_oat_filename, &output_vdex_filename, &new_oat_out, &new_vdex_out]
1273                 (bool success) {
1274    if (!success) {
1275      if (new_oat_out) {
1276        CHECK(!output_oat_filename.empty());
1277        unlink(output_oat_filename.c_str());
1278      }
1279      if (new_vdex_out) {
1280        CHECK(!output_vdex_filename.empty());
1281        unlink(output_vdex_filename.c_str());
1282      }
1283    }
1284
1285    if (kIsDebugBuild) {
1286      LOG(INFO) << "Cleaning up.. success? " << success;
1287    }
1288  };
1289
1290  if (output_oat.get() == nullptr) {
1291    cleanup(false);
1292    return EXIT_FAILURE;
1293  }
1294
1295  if (match_delta) {
1296    // Figure out what the current delta is so we can match it to the desired delta.
1297    off_t current_delta = 0;
1298    if (!ReadOatPatchDelta(elf.get(), &current_delta, &error_msg)) {
1299      LOG(ERROR) << "Unable to get current delta: " << error_msg;
1300      cleanup(false);
1301      return EXIT_FAILURE;
1302    }
1303    // Before this line base_delta is the desired final delta. We need it to be the actual amount to
1304    // change everything by. We subtract the current delta from it to make it this.
1305    base_delta -= current_delta;
1306    if (!IsAligned<kPageSize>(base_delta)) {
1307      LOG(ERROR) << "Given image file was relocated by an illegal delta";
1308      cleanup(false);
1309      return false;
1310    }
1311  }
1312
1313  if (debug) {
1314    LOG(INFO) << "moving offset by " << base_delta
1315        << " (0x" << std::hex << base_delta << ") bytes or "
1316        << std::dec << (base_delta/kPageSize) << " pages.";
1317  }
1318
1319  ScopedFlock output_oat_lock;
1320  if (lock_output) {
1321    if (!output_oat_lock.Init(output_oat.get(), &error_msg)) {
1322      LOG(ERROR) << "Unable to lock output oat " << output_oat->GetPath() << ": " << error_msg;
1323      cleanup(false);
1324      return EXIT_FAILURE;
1325    }
1326  }
1327
1328  TimingLogger::ScopedTiming pt("patch oat", &timings);
1329  bool ret = PatchOat::Patch(input_oat.get(), base_delta, output_oat.get(), &timings,
1330                             output_oat_fd >= 0,  // was it opened from FD?
1331                             new_oat_out);
1332  ret = FinishFile(output_oat.get(), ret);
1333
1334  if (ret) {
1335    if (symlink_vdex) {
1336      ret = SymlinkFile(input_vdex_filename, output_vdex_filename);
1337    } else {
1338      ret = unix_file::CopyFile(*input_vdex.get(), output_vdex.get());
1339    }
1340  }
1341
1342  if (kIsDebugBuild) {
1343    LOG(INFO) << "Exiting with return ... " << ret;
1344  }
1345  cleanup(ret);
1346  return ret ? EXIT_SUCCESS : EXIT_FAILURE;
1347}
1348
1349static int ParseFd(const StringPiece& option, const char* cmdline_arg) {
1350  int fd;
1351  const char* fd_str = option.substr(strlen(cmdline_arg)).data();
1352  if (!ParseInt(fd_str, &fd)) {
1353    Usage("Failed to parse %d argument '%s' as an integer", cmdline_arg, fd_str);
1354  }
1355  if (fd < 0) {
1356    Usage("%s pass a negative value %d", cmdline_arg, fd);
1357  }
1358  return fd;
1359}
1360
1361static int patchoat(int argc, char **argv) {
1362  InitLogging(argv);
1363  MemMap::Init();
1364  const bool debug = kIsDebugBuild;
1365  orig_argc = argc;
1366  orig_argv = argv;
1367  TimingLogger timings("patcher", false, false);
1368
1369  InitLogging(argv);
1370
1371  // Skip over the command name.
1372  argv++;
1373  argc--;
1374
1375  if (argc == 0) {
1376    Usage("No arguments specified");
1377  }
1378
1379  timings.StartTiming("Patchoat");
1380
1381  // cmd line args
1382  bool isa_set = false;
1383  InstructionSet isa = kNone;
1384  std::string input_oat_filename;
1385  std::string input_oat_location;
1386  int input_oat_fd = -1;
1387  int input_vdex_fd = -1;
1388  bool have_input_oat = false;
1389  std::string input_image_location;
1390  std::string output_oat_filename;
1391  int output_oat_fd = -1;
1392  int output_vdex_fd = -1;
1393  bool have_output_oat = false;
1394  std::string output_image_filename;
1395  off_t base_delta = 0;
1396  bool base_delta_set = false;
1397  std::string patched_image_filename;
1398  std::string patched_image_location;
1399  bool dump_timings = kIsDebugBuild;
1400  bool lock_output = true;
1401
1402  for (int i = 0; i < argc; ++i) {
1403    const StringPiece option(argv[i]);
1404    const bool log_options = false;
1405    if (log_options) {
1406      LOG(INFO) << "patchoat: option[" << i << "]=" << argv[i];
1407    }
1408    if (option.starts_with("--instruction-set=")) {
1409      isa_set = true;
1410      const char* isa_str = option.substr(strlen("--instruction-set=")).data();
1411      isa = GetInstructionSetFromString(isa_str);
1412      if (isa == kNone) {
1413        Usage("Unknown or invalid instruction set %s", isa_str);
1414      }
1415    } else if (option.starts_with("--input-oat-location=")) {
1416      if (have_input_oat) {
1417        Usage("Only one of --input-oat-file, --input-oat-location and --input-oat-fd may be used.");
1418      }
1419      have_input_oat = true;
1420      input_oat_location = option.substr(strlen("--input-oat-location=")).data();
1421    } else if (option.starts_with("--input-oat-file=")) {
1422      if (have_input_oat) {
1423        Usage("Only one of --input-oat-file, --input-oat-location and --input-oat-fd may be used.");
1424      }
1425      have_input_oat = true;
1426      input_oat_filename = option.substr(strlen("--input-oat-file=")).data();
1427    } else if (option.starts_with("--input-oat-fd=")) {
1428      if (have_input_oat) {
1429        Usage("Only one of --input-oat-file, --input-oat-location and --input-oat-fd may be used.");
1430      }
1431      have_input_oat = true;
1432      input_oat_fd = ParseFd(option, "--input-oat-fd=");
1433    } else if (option.starts_with("--input-vdex-fd=")) {
1434      input_vdex_fd = ParseFd(option, "--input-vdex-fd=");
1435    } else if (option.starts_with("--input-image-location=")) {
1436      input_image_location = option.substr(strlen("--input-image-location=")).data();
1437    } else if (option.starts_with("--output-oat-file=")) {
1438      if (have_output_oat) {
1439        Usage("Only one of --output-oat-file, and --output-oat-fd may be used.");
1440      }
1441      have_output_oat = true;
1442      output_oat_filename = option.substr(strlen("--output-oat-file=")).data();
1443    } else if (option.starts_with("--output-oat-fd=")) {
1444      if (have_output_oat) {
1445        Usage("Only one of --output-oat-file, --output-oat-fd may be used.");
1446      }
1447      have_output_oat = true;
1448      output_oat_fd = ParseFd(option, "--output-oat-fd=");
1449    } else if (option.starts_with("--output-vdex-fd=")) {
1450      output_vdex_fd = ParseFd(option, "--output-vdex-fd=");
1451    } else if (option.starts_with("--output-image-file=")) {
1452      output_image_filename = option.substr(strlen("--output-image-file=")).data();
1453    } else if (option.starts_with("--base-offset-delta=")) {
1454      const char* base_delta_str = option.substr(strlen("--base-offset-delta=")).data();
1455      base_delta_set = true;
1456      if (!ParseInt(base_delta_str, &base_delta)) {
1457        Usage("Failed to parse --base-offset-delta argument '%s' as an off_t", base_delta_str);
1458      }
1459    } else if (option.starts_with("--patched-image-location=")) {
1460      patched_image_location = option.substr(strlen("--patched-image-location=")).data();
1461    } else if (option == "--lock-output") {
1462      lock_output = true;
1463    } else if (option == "--no-lock-output") {
1464      lock_output = false;
1465    } else if (option == "--dump-timings") {
1466      dump_timings = true;
1467    } else if (option == "--no-dump-timings") {
1468      dump_timings = false;
1469    } else {
1470      Usage("Unknown argument %s", option.data());
1471    }
1472  }
1473
1474  // The instruction set is mandatory. This simplifies things...
1475  if (!isa_set) {
1476    Usage("Instruction set must be set.");
1477  }
1478
1479  int ret;
1480  if (!input_image_location.empty()) {
1481    ret = patchoat_image(timings,
1482                         isa,
1483                         input_image_location,
1484                         output_image_filename,
1485                         base_delta,
1486                         base_delta_set,
1487                         debug);
1488  } else {
1489    ret = patchoat_oat(timings,
1490                       isa,
1491                       patched_image_location,
1492                       base_delta,
1493                       base_delta_set,
1494                       input_oat_fd,
1495                       input_vdex_fd,
1496                       input_oat_location,
1497                       input_oat_filename,
1498                       have_input_oat,
1499                       output_oat_fd,
1500                       output_vdex_fd,
1501                       output_oat_filename,
1502                       have_output_oat,
1503                       lock_output,
1504                       debug);
1505  }
1506
1507  timings.EndTiming();
1508  if (dump_timings) {
1509    LOG(INFO) << Dumpable<TimingLogger>(timings);
1510  }
1511
1512  return ret;
1513}
1514
1515}  // namespace art
1516
1517int main(int argc, char **argv) {
1518  return art::patchoat(argc, argv);
1519}
1520