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