1 /*
2 * Copyright (C) 2011 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 #include "image.h"
18
19 #include <lz4.h>
20 #include <sstream>
21
22 #include "base/bit_utils.h"
23 #include "base/length_prefixed_array.h"
24 #include "base/utils.h"
25 #include "mirror/object-inl.h"
26 #include "mirror/object_array-inl.h"
27 #include "mirror/object_array.h"
28
29 namespace art {
30
31 const uint8_t ImageHeader::kImageMagic[] = { 'a', 'r', 't', '\n' };
32 // Last change: kAccNterpInvokeFastPathFlag in method modifiers.
33 const uint8_t ImageHeader::kImageVersion[] = { '0', '9', '9', '\0' };
34
ImageHeader(uint32_t image_reservation_size,uint32_t component_count,uint32_t image_begin,uint32_t image_size,ImageSection * sections,uint32_t image_roots,uint32_t oat_checksum,uint32_t oat_file_begin,uint32_t oat_data_begin,uint32_t oat_data_end,uint32_t oat_file_end,uint32_t boot_image_begin,uint32_t boot_image_size,uint32_t boot_image_component_count,uint32_t boot_image_checksum,uint32_t pointer_size)35 ImageHeader::ImageHeader(uint32_t image_reservation_size,
36 uint32_t component_count,
37 uint32_t image_begin,
38 uint32_t image_size,
39 ImageSection* sections,
40 uint32_t image_roots,
41 uint32_t oat_checksum,
42 uint32_t oat_file_begin,
43 uint32_t oat_data_begin,
44 uint32_t oat_data_end,
45 uint32_t oat_file_end,
46 uint32_t boot_image_begin,
47 uint32_t boot_image_size,
48 uint32_t boot_image_component_count,
49 uint32_t boot_image_checksum,
50 uint32_t pointer_size)
51 : image_reservation_size_(image_reservation_size),
52 component_count_(component_count),
53 image_begin_(image_begin),
54 image_size_(image_size),
55 image_checksum_(0u),
56 oat_checksum_(oat_checksum),
57 oat_file_begin_(oat_file_begin),
58 oat_data_begin_(oat_data_begin),
59 oat_data_end_(oat_data_end),
60 oat_file_end_(oat_file_end),
61 boot_image_begin_(boot_image_begin),
62 boot_image_size_(boot_image_size),
63 boot_image_component_count_(boot_image_component_count),
64 boot_image_checksum_(boot_image_checksum),
65 image_roots_(image_roots),
66 pointer_size_(pointer_size) {
67 CHECK_EQ(image_begin, RoundUp(image_begin, kPageSize));
68 CHECK_EQ(oat_file_begin, RoundUp(oat_file_begin, kPageSize));
69 CHECK_EQ(oat_data_begin, RoundUp(oat_data_begin, kPageSize));
70 CHECK_LT(image_roots, oat_file_begin);
71 CHECK_LE(oat_file_begin, oat_data_begin);
72 CHECK_LT(oat_data_begin, oat_data_end);
73 CHECK_LE(oat_data_end, oat_file_end);
74 CHECK(ValidPointerSize(pointer_size_)) << pointer_size_;
75 memcpy(magic_, kImageMagic, sizeof(kImageMagic));
76 memcpy(version_, kImageVersion, sizeof(kImageVersion));
77 std::copy_n(sections, kSectionCount, sections_);
78 }
79
RelocateImageReferences(int64_t delta)80 void ImageHeader::RelocateImageReferences(int64_t delta) {
81 CHECK_ALIGNED(delta, kPageSize) << "relocation delta must be page aligned";
82 oat_file_begin_ += delta;
83 oat_data_begin_ += delta;
84 oat_data_end_ += delta;
85 oat_file_end_ += delta;
86 image_begin_ += delta;
87 image_roots_ += delta;
88 }
89
RelocateBootImageReferences(int64_t delta)90 void ImageHeader::RelocateBootImageReferences(int64_t delta) {
91 CHECK_ALIGNED(delta, kPageSize) << "relocation delta must be page aligned";
92 DCHECK_EQ(boot_image_begin_ != 0u, boot_image_size_ != 0u);
93 if (boot_image_begin_ != 0u) {
94 boot_image_begin_ += delta;
95 }
96 for (size_t i = 0; i < kImageMethodsCount; ++i) {
97 image_methods_[i] += delta;
98 }
99 }
100
IsAppImage() const101 bool ImageHeader::IsAppImage() const {
102 // Unlike boot image and boot image extensions which include address space for
103 // oat files in their reservation size, app images are loaded separately from oat
104 // files and their reservation size is the image size rounded up to full page.
105 return image_reservation_size_ == RoundUp(image_size_, kPageSize);
106 }
107
GetImageSpaceCount() const108 uint32_t ImageHeader::GetImageSpaceCount() const {
109 DCHECK(!IsAppImage());
110 DCHECK_NE(component_count_, 0u); // Must be the header for the first component.
111 // For images compiled with --single-image, there is only one oat file. To detect
112 // that, check whether the reservation ends at the end of the first oat file.
113 return (image_begin_ + image_reservation_size_ == oat_file_end_) ? 1u : component_count_;
114 }
115
IsValid() const116 bool ImageHeader::IsValid() const {
117 if (memcmp(magic_, kImageMagic, sizeof(kImageMagic)) != 0) {
118 return false;
119 }
120 if (memcmp(version_, kImageVersion, sizeof(kImageVersion)) != 0) {
121 return false;
122 }
123 if (!IsAligned<kPageSize>(image_reservation_size_)) {
124 return false;
125 }
126 // Unsigned so wraparound is well defined.
127 if (image_begin_ >= image_begin_ + image_size_) {
128 return false;
129 }
130 if (oat_file_begin_ > oat_file_end_) {
131 return false;
132 }
133 if (oat_data_begin_ > oat_data_end_) {
134 return false;
135 }
136 if (oat_file_begin_ >= oat_data_begin_) {
137 return false;
138 }
139 return true;
140 }
141
GetMagic() const142 const char* ImageHeader::GetMagic() const {
143 CHECK(IsValid());
144 return reinterpret_cast<const char*>(magic_);
145 }
146
GetImageMethod(ImageMethod index) const147 ArtMethod* ImageHeader::GetImageMethod(ImageMethod index) const {
148 CHECK_LT(static_cast<size_t>(index), kImageMethodsCount);
149 return reinterpret_cast<ArtMethod*>(image_methods_[index]);
150 }
151
operator <<(std::ostream & os,const ImageSection & section)152 std::ostream& operator<<(std::ostream& os, const ImageSection& section) {
153 return os << "size=" << section.Size() << " range=" << section.Offset() << "-" << section.End();
154 }
155
VisitObjects(ObjectVisitor * visitor,uint8_t * base,PointerSize pointer_size) const156 void ImageHeader::VisitObjects(ObjectVisitor* visitor,
157 uint8_t* base,
158 PointerSize pointer_size) const {
159 DCHECK_EQ(pointer_size, GetPointerSize());
160 const ImageSection& objects = GetObjectsSection();
161 static const size_t kStartPos = RoundUp(sizeof(ImageHeader), kObjectAlignment);
162 for (size_t pos = kStartPos; pos < objects.Size(); ) {
163 mirror::Object* object = reinterpret_cast<mirror::Object*>(base + objects.Offset() + pos);
164 visitor->Visit(object);
165 pos += RoundUp(object->SizeOf(), kObjectAlignment);
166 }
167 }
168
GetPointerSize() const169 PointerSize ImageHeader::GetPointerSize() const {
170 return ConvertToPointerSize(pointer_size_);
171 }
172
Decompress(uint8_t * out_ptr,const uint8_t * in_ptr,std::string * error_msg) const173 bool ImageHeader::Block::Decompress(uint8_t* out_ptr,
174 const uint8_t* in_ptr,
175 std::string* error_msg) const {
176 switch (storage_mode_) {
177 case kStorageModeUncompressed: {
178 CHECK_EQ(image_size_, data_size_);
179 memcpy(out_ptr + image_offset_, in_ptr + data_offset_, data_size_);
180 break;
181 }
182 case kStorageModeLZ4:
183 case kStorageModeLZ4HC: {
184 // LZ4HC and LZ4 have same internal format, both use LZ4_decompress.
185 const size_t decompressed_size = LZ4_decompress_safe(
186 reinterpret_cast<const char*>(in_ptr) + data_offset_,
187 reinterpret_cast<char*>(out_ptr) + image_offset_,
188 data_size_,
189 image_size_);
190 CHECK_EQ(decompressed_size, image_size_);
191 break;
192 }
193 default: {
194 if (error_msg != nullptr) {
195 *error_msg = (std::ostringstream() << "Invalid image format " << storage_mode_).str();
196 }
197 return false;
198 }
199 }
200 return true;
201 }
202
GetImageSectionName(ImageSections index)203 const char* ImageHeader::GetImageSectionName(ImageSections index) {
204 switch (index) {
205 case kSectionObjects: return "Objects";
206 case kSectionArtFields: return "ArtFields";
207 case kSectionArtMethods: return "ArtMethods";
208 case kSectionRuntimeMethods: return "RuntimeMethods";
209 case kSectionImTables: return "ImTables";
210 case kSectionIMTConflictTables: return "IMTConflictTables";
211 case kSectionInternedStrings: return "InternedStrings";
212 case kSectionClassTable: return "ClassTable";
213 case kSectionStringReferenceOffsets: return "StringReferenceOffsets";
214 case kSectionMetadata: return "Metadata";
215 case kSectionImageBitmap: return "ImageBitmap";
216 case kSectionCount: return nullptr;
217 }
218 }
219
220 } // namespace art
221