patchoat.h revision 2ffb703bf431d74326c88266b4ddaf225eb3c6ad 
1/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ART_PATCHOAT_PATCHOAT_H_
18#define ART_PATCHOAT_PATCHOAT_H_
19
20#include "arch/instruction_set.h"
21#include "base/enums.h"
22#include "base/macros.h"
23#include "base/mutex.h"
24#include "elf_file.h"
25#include "elf_utils.h"
26#include "gc/accounting/space_bitmap.h"
27#include "gc/heap.h"
28#include "gc/space/image_space.h"
29#include "os.h"
30#include "runtime.h"
31
32namespace art {
33
34class ArtMethod;
35class ImageHeader;
36class OatHeader;
37
38namespace mirror {
39class Object;
40class PointerArray;
41class Reference;
42class Class;
43}  // namespace mirror
44
45class PatchOat {
46 public:
47  static bool Patch(const std::string& image_location,
48                    off_t delta,
49                    const std::string& output_directory,
50                    InstructionSet isa,
51                    TimingLogger* timings);
52
53  ~PatchOat() {}
54  PatchOat(PatchOat&&) = default;
55
56 private:
57  // All pointers are only borrowed.
58  PatchOat(InstructionSet isa, MemMap* image,
59           gc::accounting::ContinuousSpaceBitmap* bitmap, MemMap* heap, off_t delta,
60           std::map<gc::space::ImageSpace*, std::unique_ptr<MemMap>>* map, TimingLogger* timings)
61      : image_(image), bitmap_(bitmap), heap_(heap),
62        delta_(delta), isa_(isa), space_map_(map), timings_(timings) {}
63
64  // Was the .art image at image_path made with --compile-pic ?
65  static bool IsImagePic(const ImageHeader& image_header, const std::string& image_path);
66
67  enum MaybePic {
68      NOT_PIC,            // Code not pic. Patch as usual.
69      PIC,                // Code was pic. Create symlink; skip OAT patching.
70      ERROR_OAT_FILE,     // Failed to symlink oat file
71      ERROR_FIRST = ERROR_OAT_FILE,
72  };
73
74  // Was the .oat image at oat_in made with --compile-pic ?
75  static MaybePic IsOatPic(const ElfFile* oat_in);
76
77  // Attempt to replace the file with a symlink
78  // Returns false if it fails
79  static bool ReplaceOatFileWithSymlink(const std::string& input_oat_filename,
80                                        const std::string& output_oat_filename);
81
82  void VisitObject(mirror::Object* obj)
83      REQUIRES_SHARED(Locks::mutator_lock_);
84  void FixupMethod(ArtMethod* object, ArtMethod* copy)
85      REQUIRES_SHARED(Locks::mutator_lock_);
86
87  bool PatchImage(bool primary_image) REQUIRES_SHARED(Locks::mutator_lock_);
88  void PatchArtFields(const ImageHeader* image_header) REQUIRES_SHARED(Locks::mutator_lock_);
89  void PatchArtMethods(const ImageHeader* image_header) REQUIRES_SHARED(Locks::mutator_lock_);
90  void PatchImTables(const ImageHeader* image_header) REQUIRES_SHARED(Locks::mutator_lock_);
91  void PatchImtConflictTables(const ImageHeader* image_header)
92      REQUIRES_SHARED(Locks::mutator_lock_);
93  void PatchInternedStrings(const ImageHeader* image_header)
94      REQUIRES_SHARED(Locks::mutator_lock_);
95  void PatchClassTable(const ImageHeader* image_header)
96      REQUIRES_SHARED(Locks::mutator_lock_);
97  void PatchDexFileArrays(mirror::ObjectArray<mirror::Object>* img_roots)
98      REQUIRES_SHARED(Locks::mutator_lock_);
99
100  bool WriteImage(File* out);
101
102  template <typename T>
103  T* RelocatedCopyOf(T* obj) const {
104    if (obj == nullptr) {
105      return nullptr;
106    }
107    DCHECK_GT(reinterpret_cast<uintptr_t>(obj), reinterpret_cast<uintptr_t>(heap_->Begin()));
108    DCHECK_LT(reinterpret_cast<uintptr_t>(obj), reinterpret_cast<uintptr_t>(heap_->End()));
109    uintptr_t heap_off =
110        reinterpret_cast<uintptr_t>(obj) - reinterpret_cast<uintptr_t>(heap_->Begin());
111    DCHECK_LT(heap_off, image_->Size());
112    return reinterpret_cast<T*>(image_->Begin() + heap_off);
113  }
114
115  template <typename T>
116  T* RelocatedCopyOfFollowImages(T* obj) const {
117    if (obj == nullptr) {
118      return nullptr;
119    }
120    // Find ImageSpace this belongs to.
121    auto image_spaces = Runtime::Current()->GetHeap()->GetBootImageSpaces();
122    for (gc::space::ImageSpace* image_space : image_spaces) {
123      if (image_space->Contains(obj)) {
124        uintptr_t heap_off = reinterpret_cast<uintptr_t>(obj) -
125                             reinterpret_cast<uintptr_t>(image_space->GetMemMap()->Begin());
126        return reinterpret_cast<T*>(space_map_->find(image_space)->second->Begin() + heap_off);
127      }
128    }
129    LOG(FATAL) << "Did not find object in boot image space " << obj;
130    UNREACHABLE();
131  }
132
133  template <typename T>
134  T* RelocatedAddressOfPointer(T* obj) const {
135    if (obj == nullptr) {
136      return obj;
137    }
138    auto ret = reinterpret_cast<uintptr_t>(obj) + delta_;
139    // Trim off high bits in case negative relocation with 64 bit patchoat.
140    if (Is32BitISA()) {
141      ret = static_cast<uintptr_t>(static_cast<uint32_t>(ret));
142    }
143    return reinterpret_cast<T*>(ret);
144  }
145
146  bool Is32BitISA() const {
147    return InstructionSetPointerSize(isa_) == PointerSize::k32;
148  }
149
150  // Walks through the old image and patches the mmap'd copy of it to the new offset. It does not
151  // change the heap.
152  class PatchVisitor {
153   public:
154    PatchVisitor(PatchOat* patcher, mirror::Object* copy) : patcher_(patcher), copy_(copy) {}
155    ~PatchVisitor() {}
156    void operator() (ObjPtr<mirror::Object> obj, MemberOffset off, bool b) const
157        REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
158    // For reference classes.
159    void operator() (ObjPtr<mirror::Class> cls, ObjPtr<mirror::Reference>  ref) const
160        REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_);
161    // TODO: Consider using these for updating native class roots?
162    void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED)
163        const {}
164    void VisitRoot(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) const {}
165
166   private:
167    PatchOat* const patcher_;
168    mirror::Object* const copy_;
169  };
170
171  // A mmap of the image we are patching. This is modified.
172  const MemMap* const image_;
173  // The bitmap over the image within the heap we are patching. This is not modified.
174  gc::accounting::ContinuousSpaceBitmap* const bitmap_;
175  // The heap we are patching. This is not modified.
176  const MemMap* const heap_;
177  // The amount we are changing the offset by.
178  const off_t delta_;
179  // Active instruction set, used to know the entrypoint size.
180  const InstructionSet isa_;
181
182  const std::map<gc::space::ImageSpace*, std::unique_ptr<MemMap>>* space_map_;
183
184  TimingLogger* timings_;
185
186  class FixupRootVisitor;
187  class RelocatedPointerVisitor;
188  class PatchOatArtFieldVisitor;
189  class PatchOatArtMethodVisitor;
190
191  DISALLOW_IMPLICIT_CONSTRUCTORS(PatchOat);
192};
193
194}  // namespace art
195#endif  // ART_PATCHOAT_PATCHOAT_H_
196