image_space.cc revision 2974bc3d8a5d161d449dd66826d668d87bdc3cbe 
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_space.h"
18
19#include "base/stl_util.h"
20#include "base/unix_file/fd_file.h"
21#include "gc/accounting/space_bitmap-inl.h"
22#include "mirror/art_method.h"
23#include "mirror/class-inl.h"
24#include "mirror/object-inl.h"
25#include "oat_file.h"
26#include "os.h"
27#include "space-inl.h"
28#include "utils.h"
29
30namespace art {
31namespace gc {
32namespace space {
33
34Atomic<uint32_t> ImageSpace::bitmap_index_(0);
35
36ImageSpace::ImageSpace(const std::string& name, MemMap* mem_map,
37                       accounting::ContinuousSpaceBitmap* live_bitmap)
38    : MemMapSpace(name, mem_map, mem_map->Begin(), mem_map->End(), mem_map->End(),
39                  kGcRetentionPolicyNeverCollect) {
40  DCHECK(live_bitmap != nullptr);
41  live_bitmap_.reset(live_bitmap);
42}
43
44static bool GenerateImage(const std::string& image_file_name, std::string* error_msg) {
45  const std::string boot_class_path_string(Runtime::Current()->GetBootClassPathString());
46  std::vector<std::string> boot_class_path;
47  Split(boot_class_path_string, ':', boot_class_path);
48  if (boot_class_path.empty()) {
49    *error_msg = "Failed to generate image because no boot class path specified";
50    return false;
51  }
52
53  std::vector<std::string> arg_vector;
54
55  std::string dex2oat(GetAndroidRoot());
56  dex2oat += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
57  arg_vector.push_back(dex2oat);
58
59  std::string image_option_string("--image=");
60  image_option_string += image_file_name;
61  arg_vector.push_back(image_option_string);
62
63  arg_vector.push_back("--runtime-arg");
64  arg_vector.push_back("-Xms64m");
65
66  arg_vector.push_back("--runtime-arg");
67  arg_vector.push_back("-Xmx64m");
68
69
70  for (size_t i = 0; i < boot_class_path.size(); i++) {
71    arg_vector.push_back(std::string("--dex-file=") + boot_class_path[i]);
72  }
73
74  std::string oat_file_option_string("--oat-file=");
75  oat_file_option_string += image_file_name;
76  oat_file_option_string.erase(oat_file_option_string.size() - 3);
77  oat_file_option_string += "oat";
78  arg_vector.push_back(oat_file_option_string);
79
80  Runtime::Current()->AddCurrentRuntimeFeaturesAsDex2OatArguments(&arg_vector);
81
82  arg_vector.push_back(StringPrintf("--base=0x%x", ART_BASE_ADDRESS));
83
84  if (kIsTargetBuild) {
85    arg_vector.push_back("--image-classes-zip=/system/framework/framework.jar");
86    arg_vector.push_back("--image-classes=preloaded-classes");
87  } else {
88    arg_vector.push_back("--host");
89  }
90
91  const std::vector<std::string>& compiler_options = Runtime::Current()->GetImageCompilerOptions();
92  for (size_t i = 0; i < compiler_options.size(); ++i) {
93    arg_vector.push_back(compiler_options[i].c_str());
94  }
95
96  std::string command_line(Join(arg_vector, ' '));
97  LOG(INFO) << "GenerateImage: " << command_line;
98  return Exec(arg_vector, error_msg);
99}
100
101ImageSpace* ImageSpace::Create(const char* original_image_file_name,
102                               const InstructionSet image_isa) {
103  if (OS::FileExists(original_image_file_name)) {
104    // If the /system file exists, it should be up-to-date, don't try to generate
105    std::string error_msg;
106    ImageSpace* space = ImageSpace::Init(original_image_file_name, false, &error_msg);
107    if (space == nullptr) {
108      LOG(FATAL) << "Failed to load image '" << original_image_file_name << "': " << error_msg;
109    }
110    return space;
111  }
112  // If the /system file didn't exist, we need to use one from the dalvik-cache.
113  // If the cache file exists, try to open, but if it fails, regenerate.
114  // If it does not exist, generate.
115  const std::string dalvik_cache = GetDalvikCacheOrDie(GetInstructionSetString(image_isa));
116  std::string image_file_name(GetDalvikCacheFilenameOrDie(original_image_file_name,
117                                                          dalvik_cache.c_str()));
118  std::string error_msg;
119  if (OS::FileExists(image_file_name.c_str())) {
120    space::ImageSpace* image_space = ImageSpace::Init(image_file_name.c_str(), true, &error_msg);
121    if (image_space != nullptr) {
122      return image_space;
123    } else {
124      LOG(WARNING) << error_msg;
125    }
126  }
127  CHECK(GenerateImage(image_file_name, &error_msg))
128      << "Failed to generate image '" << image_file_name << "': " << error_msg;
129  ImageSpace* space = ImageSpace::Init(image_file_name.c_str(), true, &error_msg);
130  if (space == nullptr) {
131    LOG(FATAL) << "Failed to load image '" << original_image_file_name << "': " << error_msg;
132  }
133  return space;
134}
135
136void ImageSpace::VerifyImageAllocations() {
137  byte* current = Begin() + RoundUp(sizeof(ImageHeader), kObjectAlignment);
138  while (current < End()) {
139    DCHECK_ALIGNED(current, kObjectAlignment);
140    mirror::Object* obj = reinterpret_cast<mirror::Object*>(current);
141    CHECK(live_bitmap_->Test(obj));
142    CHECK(obj->GetClass() != nullptr) << "Image object at address " << obj << " has null class";
143    if (kUseBakerOrBrooksReadBarrier) {
144      obj->AssertReadBarrierPointer();
145    }
146    current += RoundUp(obj->SizeOf(), kObjectAlignment);
147  }
148}
149
150ImageSpace* ImageSpace::Init(const char* image_file_name, bool validate_oat_file,
151                             std::string* error_msg) {
152  CHECK(image_file_name != nullptr);
153
154  uint64_t start_time = 0;
155  if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
156    start_time = NanoTime();
157    LOG(INFO) << "ImageSpace::Init entering image_file_name=" << image_file_name;
158  }
159
160  UniquePtr<File> file(OS::OpenFileForReading(image_file_name));
161  if (file.get() == NULL) {
162    *error_msg = StringPrintf("Failed to open '%s'", image_file_name);
163    return nullptr;
164  }
165  ImageHeader image_header;
166  bool success = file->ReadFully(&image_header, sizeof(image_header));
167  if (!success || !image_header.IsValid()) {
168    *error_msg = StringPrintf("Invalid image header in '%s'", image_file_name);
169    return nullptr;
170  }
171
172  // Note: The image header is part of the image due to mmap page alignment required of offset.
173  UniquePtr<MemMap> map(MemMap::MapFileAtAddress(image_header.GetImageBegin(),
174                                                 image_header.GetImageSize(),
175                                                 PROT_READ | PROT_WRITE,
176                                                 MAP_PRIVATE,
177                                                 file->Fd(),
178                                                 0,
179                                                 false,
180                                                 image_file_name,
181                                                 error_msg));
182  if (map.get() == NULL) {
183    DCHECK(!error_msg->empty());
184    return nullptr;
185  }
186  CHECK_EQ(image_header.GetImageBegin(), map->Begin());
187  DCHECK_EQ(0, memcmp(&image_header, map->Begin(), sizeof(ImageHeader)));
188
189  UniquePtr<MemMap> image_map(MemMap::MapFileAtAddress(nullptr, image_header.GetImageBitmapSize(),
190                                                       PROT_READ, MAP_PRIVATE,
191                                                       file->Fd(), image_header.GetBitmapOffset(),
192                                                       false,
193                                                       image_file_name,
194                                                       error_msg));
195  if (image_map.get() == nullptr) {
196    *error_msg = StringPrintf("Failed to map image bitmap: %s", error_msg->c_str());
197    return nullptr;
198  }
199  uint32_t bitmap_index = bitmap_index_.FetchAndAdd(1);
200  std::string bitmap_name(StringPrintf("imagespace %s live-bitmap %u", image_file_name,
201                                       bitmap_index));
202  UniquePtr<accounting::ContinuousSpaceBitmap> bitmap(
203      accounting::ContinuousSpaceBitmap::CreateFromMemMap(bitmap_name, image_map.release(),
204                                                          reinterpret_cast<byte*>(map->Begin()),
205                                                          map->Size()));
206  if (bitmap.get() == nullptr) {
207    *error_msg = StringPrintf("Could not create bitmap '%s'", bitmap_name.c_str());
208    return nullptr;
209  }
210
211  Runtime* runtime = Runtime::Current();
212  mirror::Object* resolution_method = image_header.GetImageRoot(ImageHeader::kResolutionMethod);
213  runtime->SetResolutionMethod(down_cast<mirror::ArtMethod*>(resolution_method));
214  mirror::Object* imt_conflict_method = image_header.GetImageRoot(ImageHeader::kImtConflictMethod);
215  runtime->SetImtConflictMethod(down_cast<mirror::ArtMethod*>(imt_conflict_method));
216  mirror::Object* default_imt = image_header.GetImageRoot(ImageHeader::kDefaultImt);
217  runtime->SetDefaultImt(down_cast<mirror::ObjectArray<mirror::ArtMethod>*>(default_imt));
218
219  mirror::Object* callee_save_method = image_header.GetImageRoot(ImageHeader::kCalleeSaveMethod);
220  runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method), Runtime::kSaveAll);
221  callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsOnlySaveMethod);
222  runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method), Runtime::kRefsOnly);
223  callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsAndArgsSaveMethod);
224  runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method), Runtime::kRefsAndArgs);
225
226  UniquePtr<ImageSpace> space(new ImageSpace(image_file_name, map.release(), bitmap.release()));
227  if (kIsDebugBuild) {
228    space->VerifyImageAllocations();
229  }
230
231  space->oat_file_.reset(space->OpenOatFile(image_file_name, error_msg));
232  if (space->oat_file_.get() == nullptr) {
233    DCHECK(!error_msg->empty());
234    return nullptr;
235  }
236
237  if (validate_oat_file && !space->ValidateOatFile(error_msg)) {
238    DCHECK(!error_msg->empty());
239    return nullptr;
240  }
241
242  if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
243    LOG(INFO) << "ImageSpace::Init exiting (" << PrettyDuration(NanoTime() - start_time)
244             << ") " << *space.get();
245  }
246  return space.release();
247}
248
249OatFile* ImageSpace::OpenOatFile(const char* image_path, std::string* error_msg) const {
250  const ImageHeader& image_header = GetImageHeader();
251  std::string oat_filename = ImageHeader::GetOatLocationFromImageLocation(image_path);
252
253  OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, image_header.GetOatDataBegin(),
254                                    !Runtime::Current()->IsCompiler(), error_msg);
255  if (oat_file == NULL) {
256    *error_msg = StringPrintf("Failed to open oat file '%s' referenced from image %s: %s",
257                              oat_filename.c_str(), GetName(), error_msg->c_str());
258    return nullptr;
259  }
260  uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum();
261  uint32_t image_oat_checksum = image_header.GetOatChecksum();
262  if (oat_checksum != image_oat_checksum) {
263    *error_msg = StringPrintf("Failed to match oat file checksum 0x%x to expected oat checksum 0x%x"
264                              " in image %s", oat_checksum, image_oat_checksum, GetName());
265    return nullptr;
266  }
267  return oat_file;
268}
269
270bool ImageSpace::ValidateOatFile(std::string* error_msg) const {
271  CHECK(oat_file_.get() != NULL);
272  for (const OatFile::OatDexFile* oat_dex_file : oat_file_->GetOatDexFiles()) {
273    const std::string& dex_file_location = oat_dex_file->GetDexFileLocation();
274    uint32_t dex_file_location_checksum;
275    if (!DexFile::GetChecksum(dex_file_location.c_str(), &dex_file_location_checksum, error_msg)) {
276      *error_msg = StringPrintf("Failed to get checksum of dex file '%s' referenced by image %s: "
277                                "%s", dex_file_location.c_str(), GetName(), error_msg->c_str());
278      return false;
279    }
280    if (dex_file_location_checksum != oat_dex_file->GetDexFileLocationChecksum()) {
281      *error_msg = StringPrintf("ValidateOatFile found checksum mismatch between oat file '%s' and "
282                                "dex file '%s' (0x%x != 0x%x)",
283                                oat_file_->GetLocation().c_str(), dex_file_location.c_str(),
284                                oat_dex_file->GetDexFileLocationChecksum(),
285                                dex_file_location_checksum);
286      return false;
287    }
288  }
289  return true;
290}
291
292OatFile* ImageSpace::ReleaseOatFile() {
293  CHECK(oat_file_.get() != NULL);
294  return oat_file_.release();
295}
296
297void ImageSpace::Dump(std::ostream& os) const {
298  os << GetType()
299      << " begin=" << reinterpret_cast<void*>(Begin())
300      << ",end=" << reinterpret_cast<void*>(End())
301      << ",size=" << PrettySize(Size())
302      << ",name=\"" << GetName() << "\"]";
303}
304
305}  // namespace space
306}  // namespace gc
307}  // namespace art
308