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