Add verification of boot.oat generated on device
Change-Id: I069586205a9a92fc7375ccf5cdde136bbbcfc800
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index a68cc02..53b8cd9 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -18,8 +18,6 @@
#define ATRACE_TAG ATRACE_TAG_DALVIK
#include <cutils/trace.h>
-#include <sys/types.h>
-#include <sys/wait.h>
#include <limits>
#include <vector>
@@ -66,96 +64,6 @@
static const size_t kMinConcurrentRemainingBytes = 128 * KB;
const double Heap::kDefaultTargetUtilization = 0.5;
-static bool GenerateImage(const std::string& image_file_name) {
- const std::string boot_class_path_string(Runtime::Current()->GetBootClassPathString());
- std::vector<std::string> boot_class_path;
- Split(boot_class_path_string, ':', boot_class_path);
- if (boot_class_path.empty()) {
- LOG(FATAL) << "Failed to generate image because no boot class path specified";
- }
-
- std::vector<char*> arg_vector;
-
- std::string dex2oat_string(GetAndroidRoot());
- dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
- const char* dex2oat = dex2oat_string.c_str();
- arg_vector.push_back(strdup(dex2oat));
-
- std::string image_option_string("--image=");
- image_option_string += image_file_name;
- const char* image_option = image_option_string.c_str();
- arg_vector.push_back(strdup(image_option));
-
- arg_vector.push_back(strdup("--runtime-arg"));
- arg_vector.push_back(strdup("-Xms64m"));
-
- arg_vector.push_back(strdup("--runtime-arg"));
- arg_vector.push_back(strdup("-Xmx64m"));
-
- for (size_t i = 0; i < boot_class_path.size(); i++) {
- std::string dex_file_option_string("--dex-file=");
- dex_file_option_string += boot_class_path[i];
- const char* dex_file_option = dex_file_option_string.c_str();
- arg_vector.push_back(strdup(dex_file_option));
- }
-
- std::string oat_file_option_string("--oat-file=");
- oat_file_option_string += image_file_name;
- oat_file_option_string.erase(oat_file_option_string.size() - 3);
- oat_file_option_string += "oat";
- const char* oat_file_option = oat_file_option_string.c_str();
- arg_vector.push_back(strdup(oat_file_option));
-
- std::string base_option_string(StringPrintf("--base=0x%x", ART_BASE_ADDRESS));
- arg_vector.push_back(strdup(base_option_string.c_str()));
-
- if (kIsTargetBuild) {
- arg_vector.push_back(strdup("--image-classes-zip=/system/framework/framework.jar"));
- arg_vector.push_back(strdup("--image-classes=preloaded-classes"));
- } else {
- arg_vector.push_back(strdup("--host"));
- }
-
- std::string command_line(Join(arg_vector, ' '));
- LOG(INFO) << command_line;
-
- arg_vector.push_back(NULL);
- char** argv = &arg_vector[0];
-
- // fork and exec dex2oat
- pid_t pid = fork();
- if (pid == 0) {
- // no allocation allowed between fork and exec
-
- // change process groups, so we don't get reaped by ProcessManager
- setpgid(0, 0);
-
- execv(dex2oat, argv);
-
- PLOG(FATAL) << "execv(" << dex2oat << ") failed";
- return false;
- } else {
- STLDeleteElements(&arg_vector);
-
- // wait for dex2oat to finish
- int status;
- pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
- if (got_pid != pid) {
- PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
- return false;
- }
- if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
- LOG(ERROR) << dex2oat << " failed: " << command_line;
- return false;
- }
- }
- return true;
-}
-
-void Heap::UnReserveOatFileAddressRange() {
- oat_file_map_.reset(NULL);
-}
-
Heap::Heap(size_t initial_size, size_t growth_limit, size_t min_free, size_t max_free,
double target_utilization, size_t capacity,
const std::string& original_image_file_name, bool concurrent_gc)
@@ -206,45 +114,20 @@
mark_bitmap_.reset(new accounting::HeapBitmap(this));
// Requested begin for the alloc space, to follow the mapped image and oat files
- byte* requested_begin = NULL;
+ byte* requested_alloc_space_begin = NULL;
std::string image_file_name(original_image_file_name);
if (!image_file_name.empty()) {
- space::ImageSpace* image_space = NULL;
-
- if (OS::FileExists(image_file_name.c_str())) {
- // If the /system file exists, it should be up-to-date, don't try to generate
- image_space = space::ImageSpace::Create(image_file_name);
- } else {
- // If the /system file didn't exist, we need to use one from the dalvik-cache.
- // If the cache file exists, try to open, but if it fails, regenerate.
- // If it does not exist, generate.
- image_file_name = GetDalvikCacheFilenameOrDie(image_file_name);
- if (OS::FileExists(image_file_name.c_str())) {
- image_space = space::ImageSpace::Create(image_file_name);
- }
- if (image_space == NULL) {
- CHECK(GenerateImage(image_file_name)) << "Failed to generate image: " << image_file_name;
- image_space = space::ImageSpace::Create(image_file_name);
- }
- }
-
- CHECK(image_space != NULL) << "Failed to create space from " << image_file_name;
+ space::ImageSpace* image_space = space::ImageSpace::Create(image_file_name);
+ CHECK(image_space != NULL) << "Failed to create space for " << image_file_name;
AddContinuousSpace(image_space);
// Oat files referenced by image files immediately follow them in memory, ensure alloc space
// isn't going to get in the middle
byte* oat_file_end_addr = image_space->GetImageHeader().GetOatFileEnd();
CHECK_GT(oat_file_end_addr, image_space->End());
-
- // Reserve address range from image_space->End() to image_space->GetImageHeader().GetOatEnd()
- uintptr_t reserve_begin = RoundUp(reinterpret_cast<uintptr_t>(image_space->End()), kPageSize);
- uintptr_t reserve_end = RoundUp(reinterpret_cast<uintptr_t>(oat_file_end_addr), kPageSize);
- oat_file_map_.reset(MemMap::MapAnonymous("oat file reserve",
- reinterpret_cast<byte*>(reserve_begin),
- reserve_end - reserve_begin, PROT_NONE));
-
- if (oat_file_end_addr > requested_begin) {
- requested_begin = reinterpret_cast<byte*>(RoundUp(reinterpret_cast<uintptr_t>(oat_file_end_addr),
- kPageSize));
+ if (oat_file_end_addr > requested_alloc_space_begin) {
+ requested_alloc_space_begin =
+ reinterpret_cast<byte*>(RoundUp(reinterpret_cast<uintptr_t>(oat_file_end_addr),
+ kPageSize));
}
}
@@ -261,7 +144,7 @@
alloc_space_ = space::DlMallocSpace::Create("alloc space",
initial_size,
growth_limit, capacity,
- requested_begin);
+ requested_alloc_space_begin);
CHECK(alloc_space_ != NULL) << "Failed to create alloc space";
alloc_space_->SetFootprintLimit(alloc_space_->Capacity());
AddContinuousSpace(alloc_space_);
diff --git a/runtime/gc/heap.h b/runtime/gc/heap.h
index 790ab02..e6c9221 100644
--- a/runtime/gc/heap.h
+++ b/runtime/gc/heap.h
@@ -373,9 +373,6 @@
void DumpSpaces();
- // UnReserve the address range where the oat file will be placed.
- void UnReserveOatFileAddressRange();
-
// GC performance measuring
void DumpGcPerformanceInfo(std::ostream& os);
@@ -599,9 +596,6 @@
std::vector<collector::MarkSweep*> mark_sweep_collectors_;
- // A map that we use to temporarily reserve address range for the oat file.
- UniquePtr<MemMap> oat_file_map_;
-
friend class collector::MarkSweep;
friend class VerifyReferenceCardVisitor;
friend class VerifyReferenceVisitor;
diff --git a/runtime/gc/space/image_space.cc b/runtime/gc/space/image_space.cc
index 46c3937..c279ecf 100644
--- a/runtime/gc/space/image_space.cc
+++ b/runtime/gc/space/image_space.cc
@@ -16,11 +16,16 @@
#include "image_space.h"
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include "base/stl_util.h"
#include "base/unix_file/fd_file.h"
#include "gc/accounting/space_bitmap-inl.h"
#include "mirror/abstract_method.h"
#include "mirror/class-inl.h"
#include "mirror/object-inl.h"
+#include "oat_file.h"
#include "os.h"
#include "runtime.h"
#include "space-inl.h"
@@ -41,13 +46,118 @@
DCHECK(live_bitmap_.get() != NULL) << "could not create imagespace live bitmap #" << bitmap_index;
}
-ImageSpace* ImageSpace::Create(const std::string& image_file_name) {
+static bool GenerateImage(const std::string& image_file_name) {
+ const std::string boot_class_path_string(Runtime::Current()->GetBootClassPathString());
+ std::vector<std::string> boot_class_path;
+ Split(boot_class_path_string, ':', boot_class_path);
+ if (boot_class_path.empty()) {
+ LOG(FATAL) << "Failed to generate image because no boot class path specified";
+ }
+
+ std::vector<char*> arg_vector;
+
+ std::string dex2oat_string(GetAndroidRoot());
+ dex2oat_string += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
+ const char* dex2oat = dex2oat_string.c_str();
+ arg_vector.push_back(strdup(dex2oat));
+
+ std::string image_option_string("--image=");
+ image_option_string += image_file_name;
+ const char* image_option = image_option_string.c_str();
+ arg_vector.push_back(strdup(image_option));
+
+ arg_vector.push_back(strdup("--runtime-arg"));
+ arg_vector.push_back(strdup("-Xms64m"));
+
+ arg_vector.push_back(strdup("--runtime-arg"));
+ arg_vector.push_back(strdup("-Xmx64m"));
+
+ for (size_t i = 0; i < boot_class_path.size(); i++) {
+ std::string dex_file_option_string("--dex-file=");
+ dex_file_option_string += boot_class_path[i];
+ const char* dex_file_option = dex_file_option_string.c_str();
+ arg_vector.push_back(strdup(dex_file_option));
+ }
+
+ std::string oat_file_option_string("--oat-file=");
+ oat_file_option_string += image_file_name;
+ oat_file_option_string.erase(oat_file_option_string.size() - 3);
+ oat_file_option_string += "oat";
+ const char* oat_file_option = oat_file_option_string.c_str();
+ arg_vector.push_back(strdup(oat_file_option));
+
+ std::string base_option_string(StringPrintf("--base=0x%x", ART_BASE_ADDRESS));
+ arg_vector.push_back(strdup(base_option_string.c_str()));
+
+ if (kIsTargetBuild) {
+ arg_vector.push_back(strdup("--image-classes-zip=/system/framework/framework.jar"));
+ arg_vector.push_back(strdup("--image-classes=preloaded-classes"));
+ } else {
+ arg_vector.push_back(strdup("--host"));
+ }
+
+ std::string command_line(Join(arg_vector, ' '));
+ LOG(INFO) << "GenerateImage: " << command_line;
+
+ arg_vector.push_back(NULL);
+ char** argv = &arg_vector[0];
+
+ // fork and exec dex2oat
+ pid_t pid = fork();
+ if (pid == 0) {
+ // no allocation allowed between fork and exec
+
+ // change process groups, so we don't get reaped by ProcessManager
+ setpgid(0, 0);
+
+ execv(dex2oat, argv);
+
+ PLOG(FATAL) << "execv(" << dex2oat << ") failed";
+ return false;
+ } else {
+ STLDeleteElements(&arg_vector);
+
+ // wait for dex2oat to finish
+ int status;
+ pid_t got_pid = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
+ if (got_pid != pid) {
+ PLOG(ERROR) << "waitpid failed: wanted " << pid << ", got " << got_pid;
+ return false;
+ }
+ if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+ LOG(ERROR) << dex2oat << " failed: " << command_line;
+ return false;
+ }
+ }
+ return true;
+}
+
+ImageSpace* ImageSpace::Create(const std::string& original_image_file_name) {
+ if (OS::FileExists(original_image_file_name.c_str())) {
+ // If the /system file exists, it should be up-to-date, don't try to generate
+ return space::ImageSpace::Init(original_image_file_name, false);
+ }
+ // If the /system file didn't exist, we need to use one from the dalvik-cache.
+ // If the cache file exists, try to open, but if it fails, regenerate.
+ // If it does not exist, generate.
+ std::string image_file_name(GetDalvikCacheFilenameOrDie(original_image_file_name));
+ if (OS::FileExists(image_file_name.c_str())) {
+ space::ImageSpace* image_space = space::ImageSpace::Init(image_file_name, true);
+ if (image_space != NULL) {
+ return image_space;
+ }
+ }
+ CHECK(GenerateImage(image_file_name)) << "Failed to generate image: " << image_file_name;
+ return space::ImageSpace::Init(image_file_name, true);
+}
+
+ImageSpace* ImageSpace::Init(const std::string& image_file_name, bool validate_oat_file) {
CHECK(!image_file_name.empty());
uint64_t start_time = 0;
if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
start_time = NanoTime();
- LOG(INFO) << "Space::CreateImageSpace entering" << " image_file_name=" << image_file_name;
+ LOG(INFO) << "ImageSpace::Init entering image_file_name=" << image_file_name;
}
UniquePtr<File> file(OS::OpenFile(image_file_name.c_str(), false));
@@ -86,12 +196,78 @@
callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsAndArgsSaveMethod);
runtime->SetCalleeSaveMethod(down_cast<mirror::AbstractMethod*>(callee_save_method), Runtime::kRefsAndArgs);
- ImageSpace* space = new ImageSpace(image_file_name, map.release());
- if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
- LOG(INFO) << "Space::CreateImageSpace exiting (" << PrettyDuration(NanoTime() - start_time)
- << ") " << *space;
+ UniquePtr<ImageSpace> space(new ImageSpace(image_file_name, map.release()));
+
+ space->oat_file_.reset(space->OpenOatFile());
+ if (space->oat_file_.get() == NULL) {
+ LOG(ERROR) << "Failed to open oat file for image: " << image_file_name;
+ return NULL;
}
- return space;
+
+ if (validate_oat_file && !space->ValidateOatFile()) {
+ LOG(WARNING) << "Failed to validate oat file for image: " << image_file_name;
+ return NULL;
+ }
+
+ if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
+ LOG(INFO) << "ImageSpace::Init exiting (" << PrettyDuration(NanoTime() - start_time)
+ << ") " << *space.get();
+ }
+ return space.release();
+}
+
+OatFile* ImageSpace::OpenOatFile() const {
+ const Runtime* runtime = Runtime::Current();
+ const ImageHeader& image_header = GetImageHeader();
+ // Grab location but don't use Object::AsString as we haven't yet initialized the roots to
+ // check the down cast
+ mirror::String* oat_location =
+ down_cast<mirror::String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
+ std::string oat_filename;
+ oat_filename += runtime->GetHostPrefix();
+ oat_filename += oat_location->ToModifiedUtf8();
+ OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, image_header.GetOatDataBegin(),
+ !Runtime::Current()->IsCompiler());
+ if (oat_file == NULL) {
+ LOG(ERROR) << "Failed to open oat file " << oat_filename << " referenced from image.";
+ return NULL;
+ }
+ uint32_t oat_checksum = oat_file->GetOatHeader().GetChecksum();
+ uint32_t image_oat_checksum = image_header.GetOatChecksum();
+ if (oat_checksum != image_oat_checksum) {
+ LOG(ERROR) << "Failed to match oat file checksum " << std::hex << oat_checksum
+ << " to expected oat checksum " << std::hex << image_oat_checksum
+ << " in image";
+ return NULL;
+ }
+ return oat_file;
+}
+
+bool ImageSpace::ValidateOatFile() const {
+ CHECK(oat_file_.get() != NULL);
+ std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file_->GetOatDexFiles();
+ for (size_t i = 0; i < oat_dex_files.size(); i++) {
+ const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
+ const std::string& dex_file_location = oat_dex_file->GetDexFileLocation();
+ uint32_t dex_file_location_checksum;
+ if (!DexFile::GetChecksum(dex_file_location.c_str(), dex_file_location_checksum)) {
+ LOG(WARNING) << "ValidateOatFile could not find checksum for " << dex_file_location;
+ return false;
+ }
+ if (dex_file_location_checksum != oat_dex_file->GetDexFileLocationChecksum()) {
+ LOG(WARNING) << "ValidateOatFile found checksum mismatch between oat file "
+ << oat_file_->GetLocation() << " and dex file " << dex_file_location
+ << " (" << oat_dex_file->GetDexFileLocationChecksum() << " != "
+ << dex_file_location_checksum << ")";
+ return false;
+ }
+ }
+ return true;
+}
+
+OatFile& ImageSpace::ReleaseOatFile() {
+ CHECK(oat_file_.get() != NULL);
+ return *oat_file_.release();
}
void ImageSpace::RecordImageAllocations(accounting::SpaceBitmap* live_bitmap) const {
diff --git a/runtime/gc/space/image_space.h b/runtime/gc/space/image_space.h
index afec5b7..833fb8d 100644
--- a/runtime/gc/space/image_space.h
+++ b/runtime/gc/space/image_space.h
@@ -20,6 +20,9 @@
#include "space.h"
namespace art {
+
+class OatFile;
+
namespace gc {
namespace space {
@@ -34,10 +37,22 @@
return kSpaceTypeImageSpace;
}
- // create a Space from an image file. cannot be used for future allocation or collected.
+ // Create a Space from an image file. Cannot be used for future
+ // allocation or collected.
+ //
+ // Create also opens the OatFile associated with the image file so
+ // that it be contiguously allocated with the image before the
+ // creation of the alloc space. The ReleaseOatFile will later be
+ // used to transfer ownership of the OatFile to the ClassLinker when
+ // it is initialized.
static ImageSpace* Create(const std::string& image)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ // Releases the OatFile from the ImageSpace so it can be transfer to
+ // the caller, presumably the ClassLinker.
+ OatFile& ReleaseOatFile()
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
const ImageHeader& GetImageHeader() const {
return *reinterpret_cast<ImageHeader*>(Begin());
}
@@ -63,6 +78,23 @@
void Dump(std::ostream& os) const;
private:
+
+ // Tries to initialize an ImageSpace from the given image path,
+ // returning NULL on error.
+ //
+ // If validate_oat_file is false (for /system), do not verify that
+ // image's OatFile is up-to-date relative to its DexFile
+ // inputs. Otherwise (for /data), validate the inputs and generate
+ // the OatFile in /data/dalvik-cache if necessary.
+ static ImageSpace* Init(const std::string& image, bool validate_oat_file)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ OatFile* OpenOatFile() const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool ValidateOatFile() const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
friend class Space;
static size_t bitmap_index_;
@@ -71,6 +103,11 @@
ImageSpace(const std::string& name, MemMap* mem_map);
+ // The OatFile associated with the image during early startup to
+ // reserve space contiguous to the image. It is later released to
+ // the ClassLinker during it's initialization.
+ UniquePtr<OatFile> oat_file_;
+
DISALLOW_COPY_AND_ASSIGN(ImageSpace);
};