Clean up use of GetDalvikCache.
Switch the only caller of the non-void version of GetDalvikCache that set
create_if_absent true to use the void version of GetDalvikCache. Then no
callers of the non-void version of GetDalvikCache set create_if_absent to
true, so that argument is no longer needed. And without create_if_absent,
there is no case when the function will abort, so the 'OrDie" option is no
longer necessary.
Change-Id: I83f60dcc8a8f3b1f91fd2971e9028f6a7dd8384d
Test: m art-test-host
Test: m art-test-target
diff --git a/runtime/dex2oat_environment_test.h b/runtime/dex2oat_environment_test.h
index 743fbb9..d717ec0 100644
--- a/runtime/dex2oat_environment_test.h
+++ b/runtime/dex2oat_environment_test.h
@@ -137,7 +137,20 @@
}
bool GetCachedImageFile(/*out*/std::string* image, std::string* error_msg) const {
- std::string cache = GetDalvikCache(GetInstructionSetString(kRuntimeISA), true);
+ std::string cache;
+ bool have_android_data;
+ bool dalvik_cache_exists;
+ bool is_global_cache;
+ GetDalvikCache(GetInstructionSetString(kRuntimeISA),
+ true,
+ &cache,
+ &have_android_data,
+ &dalvik_cache_exists,
+ &is_global_cache);
+ if (!dalvik_cache_exists) {
+ *error_msg = "Failed to create dalvik cache";
+ return false;
+ }
return GetDalvikCacheFilename(GetImageLocation().c_str(), cache.c_str(), image, error_msg);
}
diff --git a/runtime/gc/space/image_space_fs.h b/runtime/gc/space/image_space_fs.h
index eac52f7..8e852fa 100644
--- a/runtime/gc/space/image_space_fs.h
+++ b/runtime/gc/space/image_space_fs.h
@@ -198,9 +198,11 @@
static void PruneDalvikCache(InstructionSet isa) {
CHECK_NE(isa, kNone);
// Prune the base /data/dalvik-cache.
- impl::DeleteDirectoryContents(GetDalvikCacheOrDie(".", false), false);
+ // Note: GetDalvikCache may return the empty string if the directory doesn't
+ // exist. It is safe to pass "" to DeleteDirectoryContents, so this is okay.
+ impl::DeleteDirectoryContents(GetDalvikCache("."), false);
// Prune /data/dalvik-cache/<isa>.
- impl::DeleteDirectoryContents(GetDalvikCacheOrDie(GetInstructionSetString(isa), false), false);
+ impl::DeleteDirectoryContents(GetDalvikCache(GetInstructionSetString(isa)), false);
// Be defensive. There should be a runtime created here, but this may be called in a test.
if (Runtime::Current() != nullptr) {
@@ -213,7 +215,8 @@
// present, it usually means the boot didn't complete. We wipe the entire dalvik
// cache if that's the case.
static void MarkZygoteStart(const InstructionSet isa, const uint32_t max_failed_boots) {
- const std::string isa_subdir = GetDalvikCacheOrDie(GetInstructionSetString(isa), false);
+ const std::string isa_subdir = GetDalvikCache(GetInstructionSetString(isa));
+ CHECK(!isa_subdir.empty()) << "Dalvik cache not found";
const std::string boot_marker = isa_subdir + "/.booting";
const char* file_name = boot_marker.c_str();
diff --git a/runtime/oat_file_assistant.cc b/runtime/oat_file_assistant.cc
index 2c2a2b8..0abee42 100644
--- a/runtime/oat_file_assistant.cc
+++ b/runtime/oat_file_assistant.cc
@@ -713,21 +713,15 @@
CHECK(oat_filename != nullptr);
CHECK(error_msg != nullptr);
- // TODO: The work done in GetDalvikCache is overkill for what we need.
- // Ideally a new API for getting the DalvikCacheDirectory the way we want
- // (without existence testing, creation, or death) is provided with the rest
- // of the GetDalvikCache family of functions. Until such an API is in place,
- // we use GetDalvikCache to avoid duplicating the logic for determining the
- // dalvik cache directory.
- std::string dalvik_cache_dir;
- bool ignored;
- GetDalvikCache("", false, &dalvik_cache_dir, &ignored, &ignored, &ignored);
+ std::string cache_dir = GetDalvikCache(GetInstructionSetString(isa));
+ if (cache_dir.empty()) {
+ *error_msg = "Dalvik cache directory does not exist";
+ return false;
+ }
// TODO: The oat file assistant should be the definitive place for
// determining the oat file name from the dex location, not
// GetDalvikCacheFilename.
- std::string cache_dir = StringPrintf("%s%s",
- dalvik_cache_dir.c_str(), GetInstructionSetString(isa));
return GetDalvikCacheFilename(location.c_str(), cache_dir.c_str(), oat_filename, error_msg);
}
diff --git a/runtime/utils.cc b/runtime/utils.cc
index 515ba9f..8ab8cd2 100644
--- a/runtime/utils.cc
+++ b/runtime/utils.cc
@@ -1087,58 +1087,18 @@
}
}
-static std::string GetDalvikCacheImpl(const char* subdir,
- const bool create_if_absent,
- const bool abort_on_error) {
+std::string GetDalvikCache(const char* subdir) {
CHECK(subdir != nullptr);
const char* android_data = GetAndroidData();
const std::string dalvik_cache_root(StringPrintf("%s/dalvik-cache/", android_data));
const std::string dalvik_cache = dalvik_cache_root + subdir;
if (!OS::DirectoryExists(dalvik_cache.c_str())) {
- if (!create_if_absent) {
- // TODO: Check callers. Traditional behavior is to not to abort, even when abort_on_error.
- return "";
- }
-
- // Don't create the system's /data/dalvik-cache/... because it needs special permissions.
- if (strcmp(android_data, "/data") == 0) {
- if (abort_on_error) {
- LOG(FATAL) << "Failed to find dalvik-cache directory " << dalvik_cache
- << ", cannot create /data dalvik-cache.";
- UNREACHABLE();
- }
- return "";
- }
-
- int result = mkdir(dalvik_cache_root.c_str(), 0700);
- if (result != 0 && errno != EEXIST) {
- if (abort_on_error) {
- PLOG(FATAL) << "Failed to create dalvik-cache root directory " << dalvik_cache_root;
- UNREACHABLE();
- }
- return "";
- }
-
- result = mkdir(dalvik_cache.c_str(), 0700);
- if (result != 0) {
- if (abort_on_error) {
- PLOG(FATAL) << "Failed to create dalvik-cache directory " << dalvik_cache;
- UNREACHABLE();
- }
- return "";
- }
+ // TODO: Check callers. Traditional behavior is to not abort.
+ return "";
}
return dalvik_cache;
}
-std::string GetDalvikCache(const char* subdir, const bool create_if_absent) {
- return GetDalvikCacheImpl(subdir, create_if_absent, false);
-}
-
-std::string GetDalvikCacheOrDie(const char* subdir, const bool create_if_absent) {
- return GetDalvikCacheImpl(subdir, create_if_absent, true);
-}
-
bool GetDalvikCacheFilename(const char* location, const char* cache_location,
std::string* filename, std::string* error_msg) {
if (location[0] != '/') {
diff --git a/runtime/utils.h b/runtime/utils.h
index 699b732..fd1ba23 100644
--- a/runtime/utils.h
+++ b/runtime/utils.h
@@ -251,11 +251,8 @@
const char* GetAndroidDataSafe(std::string* error_msg);
// Returns the dalvik-cache location, with subdir appended. Returns the empty string if the cache
-// could not be found (or created).
-std::string GetDalvikCache(const char* subdir, bool create_if_absent = true);
-// Returns the dalvik-cache location, or dies trying. subdir will be
-// appended to the cache location.
-std::string GetDalvikCacheOrDie(const char* subdir, bool create_if_absent = true);
+// could not be found.
+std::string GetDalvikCache(const char* subdir);
// Return true if we found the dalvik cache and stored it in the dalvik_cache argument.
// have_android_data will be set to true if we have an ANDROID_DATA that exists,
// dalvik_cache_exists will be true if there is a dalvik-cache directory that is present.
diff --git a/runtime/utils_test.cc b/runtime/utils_test.cc
index 55b6e01..d2100d1 100644
--- a/runtime/utils_test.cc
+++ b/runtime/utils_test.cc
@@ -337,11 +337,9 @@
}
TEST_F(UtilsTest, GetDalvikCache) {
- EXPECT_STREQ("", GetDalvikCache("should-not-exist123", false).c_str());
+ EXPECT_STREQ("", GetDalvikCache("should-not-exist123").c_str());
- EXPECT_STREQ((android_data_ + "/dalvik-cache/.").c_str(), GetDalvikCache(".", false).c_str());
- EXPECT_STREQ((android_data_ + "/dalvik-cache/should-not-be-there").c_str(),
- GetDalvikCache("should-not-be-there", true).c_str());
+ EXPECT_STREQ((android_data_ + "/dalvik-cache/.").c_str(), GetDalvikCache(".").c_str());
}