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 <dirent.h> 20 #include <sys/statvfs.h> 21 #include <sys/types.h> 22 #include <unistd.h> 23 24 #include <random> 25 26 #include "art_method.h" 27 #include "base/macros.h" 28 #include "base/stl_util.h" 29 #include "base/scoped_flock.h" 30 #include "base/time_utils.h" 31 #include "base/unix_file/fd_file.h" 32 #include "gc/accounting/space_bitmap-inl.h" 33 #include "mirror/class-inl.h" 34 #include "mirror/object-inl.h" 35 #include "oat_file.h" 36 #include "os.h" 37 #include "space-inl.h" 38 #include "utils.h" 39 40 namespace art { 41 namespace gc { 42 namespace space { 43 44 Atomic<uint32_t> ImageSpace::bitmap_index_(0); 45 46 ImageSpace::ImageSpace(const std::string& image_filename, const char* image_location, 47 MemMap* mem_map, accounting::ContinuousSpaceBitmap* live_bitmap, 48 uint8_t* end) 49 : MemMapSpace(image_filename, mem_map, mem_map->Begin(), end, end, 50 kGcRetentionPolicyNeverCollect), 51 image_location_(image_location) { 52 DCHECK(live_bitmap != nullptr); 53 live_bitmap_.reset(live_bitmap); 54 } 55 56 static int32_t ChooseRelocationOffsetDelta(int32_t min_delta, int32_t max_delta) { 57 CHECK_ALIGNED(min_delta, kPageSize); 58 CHECK_ALIGNED(max_delta, kPageSize); 59 CHECK_LT(min_delta, max_delta); 60 61 std::default_random_engine generator; 62 generator.seed(NanoTime() * getpid()); 63 std::uniform_int_distribution<int32_t> distribution(min_delta, max_delta); 64 int32_t r = distribution(generator); 65 if (r % 2 == 0) { 66 r = RoundUp(r, kPageSize); 67 } else { 68 r = RoundDown(r, kPageSize); 69 } 70 CHECK_LE(min_delta, r); 71 CHECK_GE(max_delta, r); 72 CHECK_ALIGNED(r, kPageSize); 73 return r; 74 } 75 76 // We are relocating or generating the core image. We should get rid of everything. It is all 77 // out-of-date. We also don't really care if this fails since it is just a convenience. 78 // Adapted from prune_dex_cache(const char* subdir) in frameworks/native/cmds/installd/commands.c 79 // Note this should only be used during first boot. 80 static void RealPruneDalvikCache(const std::string& cache_dir_path); 81 82 static void PruneDalvikCache(InstructionSet isa) { 83 CHECK_NE(isa, kNone); 84 // Prune the base /data/dalvik-cache. 85 RealPruneDalvikCache(GetDalvikCacheOrDie(".", false)); 86 // Prune /data/dalvik-cache/<isa>. 87 RealPruneDalvikCache(GetDalvikCacheOrDie(GetInstructionSetString(isa), false)); 88 } 89 90 static void RealPruneDalvikCache(const std::string& cache_dir_path) { 91 if (!OS::DirectoryExists(cache_dir_path.c_str())) { 92 return; 93 } 94 DIR* cache_dir = opendir(cache_dir_path.c_str()); 95 if (cache_dir == nullptr) { 96 PLOG(WARNING) << "Unable to open " << cache_dir_path << " to delete it's contents"; 97 return; 98 } 99 100 for (struct dirent* de = readdir(cache_dir); de != nullptr; de = readdir(cache_dir)) { 101 const char* name = de->d_name; 102 if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) { 103 continue; 104 } 105 // We only want to delete regular files and symbolic links. 106 if (de->d_type != DT_REG && de->d_type != DT_LNK) { 107 if (de->d_type != DT_DIR) { 108 // We do expect some directories (namely the <isa> for pruning the base dalvik-cache). 109 LOG(WARNING) << "Unexpected file type of " << std::hex << de->d_type << " encountered."; 110 } 111 continue; 112 } 113 std::string cache_file(cache_dir_path); 114 cache_file += '/'; 115 cache_file += name; 116 if (TEMP_FAILURE_RETRY(unlink(cache_file.c_str())) != 0) { 117 PLOG(ERROR) << "Unable to unlink " << cache_file; 118 continue; 119 } 120 } 121 CHECK_EQ(0, TEMP_FAILURE_RETRY(closedir(cache_dir))) << "Unable to close directory."; 122 } 123 124 // We write out an empty file to the zygote's ISA specific cache dir at the start of 125 // every zygote boot and delete it when the boot completes. If we find a file already 126 // present, it usually means the boot didn't complete. We wipe the entire dalvik 127 // cache if that's the case. 128 static void MarkZygoteStart(const InstructionSet isa, const uint32_t max_failed_boots) { 129 const std::string isa_subdir = GetDalvikCacheOrDie(GetInstructionSetString(isa), false); 130 const std::string boot_marker = isa_subdir + "/.booting"; 131 const char* file_name = boot_marker.c_str(); 132 133 uint32_t num_failed_boots = 0; 134 std::unique_ptr<File> file(OS::OpenFileReadWrite(file_name)); 135 if (file.get() == nullptr) { 136 file.reset(OS::CreateEmptyFile(file_name)); 137 138 if (file.get() == nullptr) { 139 PLOG(WARNING) << "Failed to create boot marker."; 140 return; 141 } 142 } else { 143 if (!file->ReadFully(&num_failed_boots, sizeof(num_failed_boots))) { 144 PLOG(WARNING) << "Failed to read boot marker."; 145 file->Erase(); 146 return; 147 } 148 } 149 150 if (max_failed_boots != 0 && num_failed_boots > max_failed_boots) { 151 LOG(WARNING) << "Incomplete boot detected. Pruning dalvik cache"; 152 RealPruneDalvikCache(isa_subdir); 153 } 154 155 ++num_failed_boots; 156 VLOG(startup) << "Number of failed boots on : " << boot_marker << " = " << num_failed_boots; 157 158 if (lseek(file->Fd(), 0, SEEK_SET) == -1) { 159 PLOG(WARNING) << "Failed to write boot marker."; 160 file->Erase(); 161 return; 162 } 163 164 if (!file->WriteFully(&num_failed_boots, sizeof(num_failed_boots))) { 165 PLOG(WARNING) << "Failed to write boot marker."; 166 file->Erase(); 167 return; 168 } 169 170 if (file->FlushCloseOrErase() != 0) { 171 PLOG(WARNING) << "Failed to flush boot marker."; 172 } 173 } 174 175 static bool GenerateImage(const std::string& image_filename, InstructionSet image_isa, 176 std::string* error_msg) { 177 const std::string boot_class_path_string(Runtime::Current()->GetBootClassPathString()); 178 std::vector<std::string> boot_class_path; 179 Split(boot_class_path_string, ':', &boot_class_path); 180 if (boot_class_path.empty()) { 181 *error_msg = "Failed to generate image because no boot class path specified"; 182 return false; 183 } 184 // We should clean up so we are more likely to have room for the image. 185 if (Runtime::Current()->IsZygote()) { 186 LOG(INFO) << "Pruning dalvik-cache since we are generating an image and will need to recompile"; 187 PruneDalvikCache(image_isa); 188 } 189 190 std::vector<std::string> arg_vector; 191 192 std::string dex2oat(Runtime::Current()->GetCompilerExecutable()); 193 arg_vector.push_back(dex2oat); 194 195 std::string image_option_string("--image="); 196 image_option_string += image_filename; 197 arg_vector.push_back(image_option_string); 198 199 for (size_t i = 0; i < boot_class_path.size(); i++) { 200 arg_vector.push_back(std::string("--dex-file=") + boot_class_path[i]); 201 } 202 203 std::string oat_file_option_string("--oat-file="); 204 oat_file_option_string += ImageHeader::GetOatLocationFromImageLocation(image_filename); 205 arg_vector.push_back(oat_file_option_string); 206 207 // Note: we do not generate a fully debuggable boot image so we do not pass the 208 // compiler flag --debuggable here. 209 210 Runtime::Current()->AddCurrentRuntimeFeaturesAsDex2OatArguments(&arg_vector); 211 CHECK_EQ(image_isa, kRuntimeISA) 212 << "We should always be generating an image for the current isa."; 213 214 int32_t base_offset = ChooseRelocationOffsetDelta(ART_BASE_ADDRESS_MIN_DELTA, 215 ART_BASE_ADDRESS_MAX_DELTA); 216 LOG(INFO) << "Using an offset of 0x" << std::hex << base_offset << " from default " 217 << "art base address of 0x" << std::hex << ART_BASE_ADDRESS; 218 arg_vector.push_back(StringPrintf("--base=0x%x", ART_BASE_ADDRESS + base_offset)); 219 220 if (!kIsTargetBuild) { 221 arg_vector.push_back("--host"); 222 } 223 224 const std::vector<std::string>& compiler_options = Runtime::Current()->GetImageCompilerOptions(); 225 for (size_t i = 0; i < compiler_options.size(); ++i) { 226 arg_vector.push_back(compiler_options[i].c_str()); 227 } 228 229 std::string command_line(Join(arg_vector, ' ')); 230 LOG(INFO) << "GenerateImage: " << command_line; 231 return Exec(arg_vector, error_msg); 232 } 233 234 bool ImageSpace::FindImageFilename(const char* image_location, 235 const InstructionSet image_isa, 236 std::string* system_filename, 237 bool* has_system, 238 std::string* cache_filename, 239 bool* dalvik_cache_exists, 240 bool* has_cache, 241 bool* is_global_cache) { 242 *has_system = false; 243 *has_cache = false; 244 // image_location = /system/framework/boot.art 245 // system_image_location = /system/framework/<image_isa>/boot.art 246 std::string system_image_filename(GetSystemImageFilename(image_location, image_isa)); 247 if (OS::FileExists(system_image_filename.c_str())) { 248 *system_filename = system_image_filename; 249 *has_system = true; 250 } 251 252 bool have_android_data = false; 253 *dalvik_cache_exists = false; 254 std::string dalvik_cache; 255 GetDalvikCache(GetInstructionSetString(image_isa), true, &dalvik_cache, 256 &have_android_data, dalvik_cache_exists, is_global_cache); 257 258 if (have_android_data && *dalvik_cache_exists) { 259 // Always set output location even if it does not exist, 260 // so that the caller knows where to create the image. 261 // 262 // image_location = /system/framework/boot.art 263 // *image_filename = /data/dalvik-cache/<image_isa>/boot.art 264 std::string error_msg; 265 if (!GetDalvikCacheFilename(image_location, dalvik_cache.c_str(), cache_filename, &error_msg)) { 266 LOG(WARNING) << error_msg; 267 return *has_system; 268 } 269 *has_cache = OS::FileExists(cache_filename->c_str()); 270 } 271 return *has_system || *has_cache; 272 } 273 274 static bool ReadSpecificImageHeader(const char* filename, ImageHeader* image_header) { 275 std::unique_ptr<File> image_file(OS::OpenFileForReading(filename)); 276 if (image_file.get() == nullptr) { 277 return false; 278 } 279 const bool success = image_file->ReadFully(image_header, sizeof(ImageHeader)); 280 if (!success || !image_header->IsValid()) { 281 return false; 282 } 283 return true; 284 } 285 286 // Relocate the image at image_location to dest_filename and relocate it by a random amount. 287 static bool RelocateImage(const char* image_location, const char* dest_filename, 288 InstructionSet isa, std::string* error_msg) { 289 // We should clean up so we are more likely to have room for the image. 290 if (Runtime::Current()->IsZygote()) { 291 LOG(INFO) << "Pruning dalvik-cache since we are relocating an image and will need to recompile"; 292 PruneDalvikCache(isa); 293 } 294 295 std::string patchoat(Runtime::Current()->GetPatchoatExecutable()); 296 297 std::string input_image_location_arg("--input-image-location="); 298 input_image_location_arg += image_location; 299 300 std::string output_image_filename_arg("--output-image-file="); 301 output_image_filename_arg += dest_filename; 302 303 std::string input_oat_location_arg("--input-oat-location="); 304 input_oat_location_arg += ImageHeader::GetOatLocationFromImageLocation(image_location); 305 306 std::string output_oat_filename_arg("--output-oat-file="); 307 output_oat_filename_arg += ImageHeader::GetOatLocationFromImageLocation(dest_filename); 308 309 std::string instruction_set_arg("--instruction-set="); 310 instruction_set_arg += GetInstructionSetString(isa); 311 312 std::string base_offset_arg("--base-offset-delta="); 313 StringAppendF(&base_offset_arg, "%d", ChooseRelocationOffsetDelta(ART_BASE_ADDRESS_MIN_DELTA, 314 ART_BASE_ADDRESS_MAX_DELTA)); 315 316 std::vector<std::string> argv; 317 argv.push_back(patchoat); 318 319 argv.push_back(input_image_location_arg); 320 argv.push_back(output_image_filename_arg); 321 322 argv.push_back(input_oat_location_arg); 323 argv.push_back(output_oat_filename_arg); 324 325 argv.push_back(instruction_set_arg); 326 argv.push_back(base_offset_arg); 327 328 std::string command_line(Join(argv, ' ')); 329 LOG(INFO) << "RelocateImage: " << command_line; 330 return Exec(argv, error_msg); 331 } 332 333 static ImageHeader* ReadSpecificImageHeader(const char* filename, std::string* error_msg) { 334 std::unique_ptr<ImageHeader> hdr(new ImageHeader); 335 if (!ReadSpecificImageHeader(filename, hdr.get())) { 336 *error_msg = StringPrintf("Unable to read image header for %s", filename); 337 return nullptr; 338 } 339 return hdr.release(); 340 } 341 342 ImageHeader* ImageSpace::ReadImageHeaderOrDie(const char* image_location, 343 const InstructionSet image_isa) { 344 std::string error_msg; 345 ImageHeader* image_header = ReadImageHeader(image_location, image_isa, &error_msg); 346 if (image_header == nullptr) { 347 LOG(FATAL) << error_msg; 348 } 349 return image_header; 350 } 351 352 ImageHeader* ImageSpace::ReadImageHeader(const char* image_location, 353 const InstructionSet image_isa, 354 std::string* error_msg) { 355 std::string system_filename; 356 bool has_system = false; 357 std::string cache_filename; 358 bool has_cache = false; 359 bool dalvik_cache_exists = false; 360 bool is_global_cache = false; 361 if (FindImageFilename(image_location, image_isa, &system_filename, &has_system, 362 &cache_filename, &dalvik_cache_exists, &has_cache, &is_global_cache)) { 363 if (Runtime::Current()->ShouldRelocate()) { 364 if (has_system && has_cache) { 365 std::unique_ptr<ImageHeader> sys_hdr(new ImageHeader); 366 std::unique_ptr<ImageHeader> cache_hdr(new ImageHeader); 367 if (!ReadSpecificImageHeader(system_filename.c_str(), sys_hdr.get())) { 368 *error_msg = StringPrintf("Unable to read image header for %s at %s", 369 image_location, system_filename.c_str()); 370 return nullptr; 371 } 372 if (!ReadSpecificImageHeader(cache_filename.c_str(), cache_hdr.get())) { 373 *error_msg = StringPrintf("Unable to read image header for %s at %s", 374 image_location, cache_filename.c_str()); 375 return nullptr; 376 } 377 if (sys_hdr->GetOatChecksum() != cache_hdr->GetOatChecksum()) { 378 *error_msg = StringPrintf("Unable to find a relocated version of image file %s", 379 image_location); 380 return nullptr; 381 } 382 return cache_hdr.release(); 383 } else if (!has_cache) { 384 *error_msg = StringPrintf("Unable to find a relocated version of image file %s", 385 image_location); 386 return nullptr; 387 } else if (!has_system && has_cache) { 388 // This can probably just use the cache one. 389 return ReadSpecificImageHeader(cache_filename.c_str(), error_msg); 390 } 391 } else { 392 // We don't want to relocate, Just pick the appropriate one if we have it and return. 393 if (has_system && has_cache) { 394 // We want the cache if the checksum matches, otherwise the system. 395 std::unique_ptr<ImageHeader> system(ReadSpecificImageHeader(system_filename.c_str(), 396 error_msg)); 397 std::unique_ptr<ImageHeader> cache(ReadSpecificImageHeader(cache_filename.c_str(), 398 error_msg)); 399 if (system.get() == nullptr || 400 (cache.get() != nullptr && cache->GetOatChecksum() == system->GetOatChecksum())) { 401 return cache.release(); 402 } else { 403 return system.release(); 404 } 405 } else if (has_system) { 406 return ReadSpecificImageHeader(system_filename.c_str(), error_msg); 407 } else if (has_cache) { 408 return ReadSpecificImageHeader(cache_filename.c_str(), error_msg); 409 } 410 } 411 } 412 413 *error_msg = StringPrintf("Unable to find image file for %s", image_location); 414 return nullptr; 415 } 416 417 static bool ChecksumsMatch(const char* image_a, const char* image_b) { 418 ImageHeader hdr_a; 419 ImageHeader hdr_b; 420 return ReadSpecificImageHeader(image_a, &hdr_a) && ReadSpecificImageHeader(image_b, &hdr_b) 421 && hdr_a.GetOatChecksum() == hdr_b.GetOatChecksum(); 422 } 423 424 static bool ImageCreationAllowed(bool is_global_cache, std::string* error_msg) { 425 // Anyone can write into a "local" cache. 426 if (!is_global_cache) { 427 return true; 428 } 429 430 // Only the zygote is allowed to create the global boot image. 431 if (Runtime::Current()->IsZygote()) { 432 return true; 433 } 434 435 *error_msg = "Only the zygote can create the global boot image."; 436 return false; 437 } 438 439 static constexpr uint64_t kLowSpaceValue = 50 * MB; 440 static constexpr uint64_t kTmpFsSentinelValue = 384 * MB; 441 442 // Read the free space of the cache partition and make a decision whether to keep the generated 443 // image. This is to try to mitigate situations where the system might run out of space later. 444 static bool CheckSpace(const std::string& cache_filename, std::string* error_msg) { 445 // Using statvfs vs statvfs64 because of b/18207376, and it is enough for all practical purposes. 446 struct statvfs buf; 447 448 int res = TEMP_FAILURE_RETRY(statvfs(cache_filename.c_str(), &buf)); 449 if (res != 0) { 450 // Could not stat. Conservatively tell the system to delete the image. 451 *error_msg = "Could not stat the filesystem, assuming low-memory situation."; 452 return false; 453 } 454 455 uint64_t fs_overall_size = buf.f_bsize * static_cast<uint64_t>(buf.f_blocks); 456 // Zygote is privileged, but other things are not. Use bavail. 457 uint64_t fs_free_size = buf.f_bsize * static_cast<uint64_t>(buf.f_bavail); 458 459 // Take the overall size as an indicator for a tmpfs, which is being used for the decryption 460 // environment. We do not want to fail quickening the boot image there, as it is beneficial 461 // for time-to-UI. 462 if (fs_overall_size > kTmpFsSentinelValue) { 463 if (fs_free_size < kLowSpaceValue) { 464 *error_msg = StringPrintf("Low-memory situation: only %4.2f megabytes available after image" 465 " generation, need at least %" PRIu64 ".", 466 static_cast<double>(fs_free_size) / MB, 467 kLowSpaceValue / MB); 468 return false; 469 } 470 } 471 return true; 472 } 473 474 ImageSpace* ImageSpace::Create(const char* image_location, 475 const InstructionSet image_isa, 476 std::string* error_msg) { 477 std::string system_filename; 478 bool has_system = false; 479 std::string cache_filename; 480 bool has_cache = false; 481 bool dalvik_cache_exists = false; 482 bool is_global_cache = true; 483 const bool found_image = FindImageFilename(image_location, image_isa, &system_filename, 484 &has_system, &cache_filename, &dalvik_cache_exists, 485 &has_cache, &is_global_cache); 486 487 if (Runtime::Current()->IsZygote()) { 488 MarkZygoteStart(image_isa, Runtime::Current()->GetZygoteMaxFailedBoots()); 489 } 490 491 ImageSpace* space; 492 bool relocate = Runtime::Current()->ShouldRelocate(); 493 bool can_compile = Runtime::Current()->IsImageDex2OatEnabled(); 494 if (found_image) { 495 const std::string* image_filename; 496 bool is_system = false; 497 bool relocated_version_used = false; 498 if (relocate) { 499 if (!dalvik_cache_exists) { 500 *error_msg = StringPrintf("Requiring relocation for image '%s' at '%s' but we do not have " 501 "any dalvik_cache to find/place it in.", 502 image_location, system_filename.c_str()); 503 return nullptr; 504 } 505 if (has_system) { 506 if (has_cache && ChecksumsMatch(system_filename.c_str(), cache_filename.c_str())) { 507 // We already have a relocated version 508 image_filename = &cache_filename; 509 relocated_version_used = true; 510 } else { 511 // We cannot have a relocated version, Relocate the system one and use it. 512 513 std::string reason; 514 bool success; 515 516 // Check whether we are allowed to relocate. 517 if (!can_compile) { 518 reason = "Image dex2oat disabled by -Xnoimage-dex2oat."; 519 success = false; 520 } else if (!ImageCreationAllowed(is_global_cache, &reason)) { 521 // Whether we can write to the cache. 522 success = false; 523 } else { 524 // Try to relocate. 525 success = RelocateImage(image_location, cache_filename.c_str(), image_isa, &reason); 526 } 527 528 if (success) { 529 relocated_version_used = true; 530 image_filename = &cache_filename; 531 } else { 532 *error_msg = StringPrintf("Unable to relocate image '%s' from '%s' to '%s': %s", 533 image_location, system_filename.c_str(), 534 cache_filename.c_str(), reason.c_str()); 535 // We failed to create files, remove any possibly garbage output. 536 // Since ImageCreationAllowed was true above, we are the zygote 537 // and therefore the only process expected to generate these for 538 // the device. 539 PruneDalvikCache(image_isa); 540 return nullptr; 541 } 542 } 543 } else { 544 CHECK(has_cache); 545 // We can just use cache's since it should be fine. This might or might not be relocated. 546 image_filename = &cache_filename; 547 } 548 } else { 549 if (has_system && has_cache) { 550 // Check they have the same cksum. If they do use the cache. Otherwise system. 551 if (ChecksumsMatch(system_filename.c_str(), cache_filename.c_str())) { 552 image_filename = &cache_filename; 553 relocated_version_used = true; 554 } else { 555 image_filename = &system_filename; 556 is_system = true; 557 } 558 } else if (has_system) { 559 image_filename = &system_filename; 560 is_system = true; 561 } else { 562 CHECK(has_cache); 563 image_filename = &cache_filename; 564 } 565 } 566 { 567 // Note that we must not use the file descriptor associated with 568 // ScopedFlock::GetFile to Init the image file. We want the file 569 // descriptor (and the associated exclusive lock) to be released when 570 // we leave Create. 571 ScopedFlock image_lock; 572 image_lock.Init(image_filename->c_str(), error_msg); 573 VLOG(startup) << "Using image file " << image_filename->c_str() << " for image location " 574 << image_location; 575 // If we are in /system we can assume the image is good. We can also 576 // assume this if we are using a relocated image (i.e. image checksum 577 // matches) since this is only different by the offset. We need this to 578 // make sure that host tests continue to work. 579 space = ImageSpace::Init(image_filename->c_str(), image_location, 580 !(is_system || relocated_version_used), error_msg); 581 } 582 if (space != nullptr) { 583 return space; 584 } 585 586 if (relocated_version_used) { 587 // Something is wrong with the relocated copy (even though checksums match). Cleanup. 588 // This can happen if the .oat is corrupt, since the above only checks the .art checksums. 589 // TODO: Check the oat file validity earlier. 590 *error_msg = StringPrintf("Attempted to use relocated version of %s at %s generated from %s " 591 "but image failed to load: %s", 592 image_location, cache_filename.c_str(), system_filename.c_str(), 593 error_msg->c_str()); 594 PruneDalvikCache(image_isa); 595 return nullptr; 596 } else if (is_system) { 597 // If the /system file exists, it should be up-to-date, don't try to generate it. 598 *error_msg = StringPrintf("Failed to load /system image '%s': %s", 599 image_filename->c_str(), error_msg->c_str()); 600 return nullptr; 601 } else { 602 // Otherwise, log a warning and fall through to GenerateImage. 603 LOG(WARNING) << *error_msg; 604 } 605 } 606 607 if (!can_compile) { 608 *error_msg = "Not attempting to compile image because -Xnoimage-dex2oat"; 609 return nullptr; 610 } else if (!dalvik_cache_exists) { 611 *error_msg = StringPrintf("No place to put generated image."); 612 return nullptr; 613 } else if (!ImageCreationAllowed(is_global_cache, error_msg)) { 614 return nullptr; 615 } else if (!GenerateImage(cache_filename, image_isa, error_msg)) { 616 *error_msg = StringPrintf("Failed to generate image '%s': %s", 617 cache_filename.c_str(), error_msg->c_str()); 618 // We failed to create files, remove any possibly garbage output. 619 // Since ImageCreationAllowed was true above, we are the zygote 620 // and therefore the only process expected to generate these for 621 // the device. 622 PruneDalvikCache(image_isa); 623 return nullptr; 624 } else { 625 // Check whether there is enough space left over after we have generated the image. 626 if (!CheckSpace(cache_filename, error_msg)) { 627 // No. Delete the generated image and try to run out of the dex files. 628 PruneDalvikCache(image_isa); 629 return nullptr; 630 } 631 632 // Note that we must not use the file descriptor associated with 633 // ScopedFlock::GetFile to Init the image file. We want the file 634 // descriptor (and the associated exclusive lock) to be released when 635 // we leave Create. 636 ScopedFlock image_lock; 637 image_lock.Init(cache_filename.c_str(), error_msg); 638 space = ImageSpace::Init(cache_filename.c_str(), image_location, true, error_msg); 639 if (space == nullptr) { 640 *error_msg = StringPrintf("Failed to load generated image '%s': %s", 641 cache_filename.c_str(), error_msg->c_str()); 642 } 643 return space; 644 } 645 } 646 647 void ImageSpace::VerifyImageAllocations() { 648 uint8_t* current = Begin() + RoundUp(sizeof(ImageHeader), kObjectAlignment); 649 while (current < End()) { 650 CHECK_ALIGNED(current, kObjectAlignment); 651 auto* obj = reinterpret_cast<mirror::Object*>(current); 652 CHECK(obj->GetClass() != nullptr) << "Image object at address " << obj << " has null class"; 653 CHECK(live_bitmap_->Test(obj)) << PrettyTypeOf(obj); 654 if (kUseBakerOrBrooksReadBarrier) { 655 obj->AssertReadBarrierPointer(); 656 } 657 current += RoundUp(obj->SizeOf(), kObjectAlignment); 658 } 659 } 660 661 ImageSpace* ImageSpace::Init(const char* image_filename, const char* image_location, 662 bool validate_oat_file, std::string* error_msg) { 663 CHECK(image_filename != nullptr); 664 CHECK(image_location != nullptr); 665 666 uint64_t start_time = 0; 667 if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) { 668 start_time = NanoTime(); 669 LOG(INFO) << "ImageSpace::Init entering image_filename=" << image_filename; 670 } 671 672 std::unique_ptr<File> file(OS::OpenFileForReading(image_filename)); 673 if (file.get() == nullptr) { 674 *error_msg = StringPrintf("Failed to open '%s'", image_filename); 675 return nullptr; 676 } 677 ImageHeader image_header; 678 bool success = file->ReadFully(&image_header, sizeof(image_header)); 679 if (!success || !image_header.IsValid()) { 680 *error_msg = StringPrintf("Invalid image header in '%s'", image_filename); 681 return nullptr; 682 } 683 // Check that the file is large enough. 684 uint64_t image_file_size = static_cast<uint64_t>(file->GetLength()); 685 if (image_header.GetImageSize() > image_file_size) { 686 *error_msg = StringPrintf("Image file too small for image heap: %" PRIu64 " vs. %zu.", 687 image_file_size, image_header.GetImageSize()); 688 return nullptr; 689 } 690 691 if (kIsDebugBuild) { 692 LOG(INFO) << "Dumping image sections"; 693 for (size_t i = 0; i < ImageHeader::kSectionCount; ++i) { 694 const auto section_idx = static_cast<ImageHeader::ImageSections>(i); 695 auto& section = image_header.GetImageSection(section_idx); 696 LOG(INFO) << section_idx << " start=" 697 << reinterpret_cast<void*>(image_header.GetImageBegin() + section.Offset()) << " " 698 << section; 699 } 700 } 701 702 const auto& bitmap_section = image_header.GetImageSection(ImageHeader::kSectionImageBitmap); 703 auto end_of_bitmap = static_cast<size_t>(bitmap_section.End()); 704 if (end_of_bitmap != image_file_size) { 705 *error_msg = StringPrintf( 706 "Image file size does not equal end of bitmap: size=%" PRIu64 " vs. %zu.", image_file_size, 707 end_of_bitmap); 708 return nullptr; 709 } 710 711 // Note: The image header is part of the image due to mmap page alignment required of offset. 712 std::unique_ptr<MemMap> map(MemMap::MapFileAtAddress( 713 image_header.GetImageBegin(), image_header.GetImageSize(), 714 PROT_READ | PROT_WRITE, MAP_PRIVATE, file->Fd(), 0, false, image_filename, error_msg)); 715 if (map.get() == nullptr) { 716 DCHECK(!error_msg->empty()); 717 return nullptr; 718 } 719 CHECK_EQ(image_header.GetImageBegin(), map->Begin()); 720 DCHECK_EQ(0, memcmp(&image_header, map->Begin(), sizeof(ImageHeader))); 721 722 std::unique_ptr<MemMap> image_map(MemMap::MapFileAtAddress( 723 nullptr, bitmap_section.Size(), PROT_READ, MAP_PRIVATE, file->Fd(), 724 bitmap_section.Offset(), false, image_filename, error_msg)); 725 if (image_map.get() == nullptr) { 726 *error_msg = StringPrintf("Failed to map image bitmap: %s", error_msg->c_str()); 727 return nullptr; 728 } 729 uint32_t bitmap_index = bitmap_index_.FetchAndAddSequentiallyConsistent(1); 730 std::string bitmap_name(StringPrintf("imagespace %s live-bitmap %u", image_filename, 731 bitmap_index)); 732 std::unique_ptr<accounting::ContinuousSpaceBitmap> bitmap( 733 accounting::ContinuousSpaceBitmap::CreateFromMemMap( 734 bitmap_name, image_map.release(), reinterpret_cast<uint8_t*>(map->Begin()), 735 accounting::ContinuousSpaceBitmap::ComputeHeapSize(bitmap_section.Size()))); 736 if (bitmap.get() == nullptr) { 737 *error_msg = StringPrintf("Could not create bitmap '%s'", bitmap_name.c_str()); 738 return nullptr; 739 } 740 741 // We only want the mirror object, not the ArtFields and ArtMethods. 742 uint8_t* const image_end = 743 map->Begin() + image_header.GetImageSection(ImageHeader::kSectionObjects).End(); 744 std::unique_ptr<ImageSpace> space(new ImageSpace(image_filename, image_location, 745 map.release(), bitmap.release(), image_end)); 746 747 // VerifyImageAllocations() will be called later in Runtime::Init() 748 // as some class roots like ArtMethod::java_lang_reflect_ArtMethod_ 749 // and ArtField::java_lang_reflect_ArtField_, which are used from 750 // Object::SizeOf() which VerifyImageAllocations() calls, are not 751 // set yet at this point. 752 753 space->oat_file_.reset(space->OpenOatFile(image_filename, error_msg)); 754 if (space->oat_file_.get() == nullptr) { 755 DCHECK(!error_msg->empty()); 756 return nullptr; 757 } 758 space->oat_file_non_owned_ = space->oat_file_.get(); 759 760 if (validate_oat_file && !space->ValidateOatFile(error_msg)) { 761 DCHECK(!error_msg->empty()); 762 return nullptr; 763 } 764 765 Runtime* runtime = Runtime::Current(); 766 runtime->SetInstructionSet(space->oat_file_->GetOatHeader().GetInstructionSet()); 767 768 runtime->SetResolutionMethod(image_header.GetImageMethod(ImageHeader::kResolutionMethod)); 769 runtime->SetImtConflictMethod(image_header.GetImageMethod(ImageHeader::kImtConflictMethod)); 770 runtime->SetImtUnimplementedMethod( 771 image_header.GetImageMethod(ImageHeader::kImtUnimplementedMethod)); 772 runtime->SetCalleeSaveMethod( 773 image_header.GetImageMethod(ImageHeader::kCalleeSaveMethod), Runtime::kSaveAll); 774 runtime->SetCalleeSaveMethod( 775 image_header.GetImageMethod(ImageHeader::kRefsOnlySaveMethod), Runtime::kRefsOnly); 776 runtime->SetCalleeSaveMethod( 777 image_header.GetImageMethod(ImageHeader::kRefsAndArgsSaveMethod), Runtime::kRefsAndArgs); 778 779 if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) { 780 LOG(INFO) << "ImageSpace::Init exiting (" << PrettyDuration(NanoTime() - start_time) 781 << ") " << *space.get(); 782 } 783 return space.release(); 784 } 785 786 OatFile* ImageSpace::OpenOatFile(const char* image_path, std::string* error_msg) const { 787 const ImageHeader& image_header = GetImageHeader(); 788 std::string oat_filename = ImageHeader::GetOatLocationFromImageLocation(image_path); 789 790 CHECK(image_header.GetOatDataBegin() != nullptr); 791 792 OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, image_header.GetOatDataBegin(), 793 image_header.GetOatFileBegin(), 794 !Runtime::Current()->IsAotCompiler(), 795 nullptr, error_msg); 796 if (oat_file == nullptr) { 797 *error_msg = StringPrintf("Failed to open oat file '%s' referenced from image %s: %s", 798 oat_filename.c_str(), GetName(), error_msg->c_str()); 799 return nullptr; 800 } 801 uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum(); 802 uint32_t image_oat_checksum = image_header.GetOatChecksum(); 803 if (oat_checksum != image_oat_checksum) { 804 *error_msg = StringPrintf("Failed to match oat file checksum 0x%x to expected oat checksum 0x%x" 805 " in image %s", oat_checksum, image_oat_checksum, GetName()); 806 return nullptr; 807 } 808 int32_t image_patch_delta = image_header.GetPatchDelta(); 809 int32_t oat_patch_delta = oat_file->GetOatHeader().GetImagePatchDelta(); 810 if (oat_patch_delta != image_patch_delta && !image_header.CompilePic()) { 811 // We should have already relocated by this point. Bail out. 812 *error_msg = StringPrintf("Failed to match oat file patch delta %d to expected patch delta %d " 813 "in image %s", oat_patch_delta, image_patch_delta, GetName()); 814 return nullptr; 815 } 816 817 return oat_file; 818 } 819 820 bool ImageSpace::ValidateOatFile(std::string* error_msg) const { 821 CHECK(oat_file_.get() != nullptr); 822 for (const OatFile::OatDexFile* oat_dex_file : oat_file_->GetOatDexFiles()) { 823 const std::string& dex_file_location = oat_dex_file->GetDexFileLocation(); 824 uint32_t dex_file_location_checksum; 825 if (!DexFile::GetChecksum(dex_file_location.c_str(), &dex_file_location_checksum, error_msg)) { 826 *error_msg = StringPrintf("Failed to get checksum of dex file '%s' referenced by image %s: " 827 "%s", dex_file_location.c_str(), GetName(), error_msg->c_str()); 828 return false; 829 } 830 if (dex_file_location_checksum != oat_dex_file->GetDexFileLocationChecksum()) { 831 *error_msg = StringPrintf("ValidateOatFile found checksum mismatch between oat file '%s' and " 832 "dex file '%s' (0x%x != 0x%x)", 833 oat_file_->GetLocation().c_str(), dex_file_location.c_str(), 834 oat_dex_file->GetDexFileLocationChecksum(), 835 dex_file_location_checksum); 836 return false; 837 } 838 } 839 return true; 840 } 841 842 843 const OatFile* ImageSpace::GetOatFile() const { 844 return oat_file_non_owned_; 845 } 846 847 848 OatFile* ImageSpace::ReleaseOatFile() { 849 CHECK(oat_file_.get() != nullptr); 850 return oat_file_.release(); 851 } 852 853 void ImageSpace::Dump(std::ostream& os) const { 854 os << GetType() 855 << " begin=" << reinterpret_cast<void*>(Begin()) 856 << ",end=" << reinterpret_cast<void*>(End()) 857 << ",size=" << PrettySize(Size()) 858 << ",name=\"" << GetName() << "\"]"; 859 } 860 861 } // namespace space 862 } // namespace gc 863 } // namespace art 864
