| /* |
| * Copyright (C) 2022 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "artd.h" |
| |
| #include <fcntl.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| #include <algorithm> |
| #include <chrono> |
| #include <condition_variable> |
| #include <csignal> |
| #include <filesystem> |
| #include <functional> |
| #include <memory> |
| #include <mutex> |
| #include <optional> |
| #include <string> |
| #include <thread> |
| #include <type_traits> |
| #include <unordered_set> |
| #include <utility> |
| #include <vector> |
| |
| #include "aidl/com/android/server/art/ArtConstants.h" |
| #include "aidl/com/android/server/art/BnArtd.h" |
| #include "android-base/collections.h" |
| #include "android-base/errors.h" |
| #include "android-base/file.h" |
| #include "android-base/logging.h" |
| #include "android-base/parseint.h" |
| #include "android-base/result.h" |
| #include "android-base/scopeguard.h" |
| #include "android-base/strings.h" |
| #include "android/binder_auto_utils.h" |
| #include "android/binder_status.h" |
| #include "base/array_ref.h" |
| #include "base/common_art_test.h" |
| #include "exec_utils.h" |
| #include "fmt/format.h" |
| #include "gmock/gmock.h" |
| #include "gtest/gtest.h" |
| #include "oat_file.h" |
| #include "path_utils.h" |
| #include "profman/profman_result.h" |
| #include "testing.h" |
| #include "tools/system_properties.h" |
| |
| namespace art { |
| namespace artd { |
| namespace { |
| |
| using ::aidl::com::android::server::art::ArtConstants; |
| using ::aidl::com::android::server::art::ArtdDexoptResult; |
| using ::aidl::com::android::server::art::ArtifactsPath; |
| using ::aidl::com::android::server::art::DexMetadataPath; |
| using ::aidl::com::android::server::art::DexoptOptions; |
| using ::aidl::com::android::server::art::FileVisibility; |
| using ::aidl::com::android::server::art::FsPermission; |
| using ::aidl::com::android::server::art::GetDexoptStatusResult; |
| using ::aidl::com::android::server::art::IArtdCancellationSignal; |
| using ::aidl::com::android::server::art::OutputArtifacts; |
| using ::aidl::com::android::server::art::OutputProfile; |
| using ::aidl::com::android::server::art::PriorityClass; |
| using ::aidl::com::android::server::art::ProfilePath; |
| using ::aidl::com::android::server::art::VdexPath; |
| using ::android::base::Append; |
| using ::android::base::Error; |
| using ::android::base::make_scope_guard; |
| using ::android::base::ParseInt; |
| using ::android::base::ReadFdToString; |
| using ::android::base::ReadFileToString; |
| using ::android::base::Result; |
| using ::android::base::ScopeGuard; |
| using ::android::base::Split; |
| using ::android::base::WriteStringToFd; |
| using ::android::base::WriteStringToFile; |
| using ::testing::_; |
| using ::testing::AllOf; |
| using ::testing::AnyNumber; |
| using ::testing::AnyOf; |
| using ::testing::Contains; |
| using ::testing::ContainsRegex; |
| using ::testing::DoAll; |
| using ::testing::ElementsAre; |
| using ::testing::Field; |
| using ::testing::HasSubstr; |
| using ::testing::IsEmpty; |
| using ::testing::Matcher; |
| using ::testing::MockFunction; |
| using ::testing::Not; |
| using ::testing::Property; |
| using ::testing::ResultOf; |
| using ::testing::Return; |
| using ::testing::SetArgPointee; |
| using ::testing::UnorderedElementsAreArray; |
| using ::testing::WithArg; |
| |
| using PrimaryCurProfilePath = ProfilePath::PrimaryCurProfilePath; |
| using PrimaryRefProfilePath = ProfilePath::PrimaryRefProfilePath; |
| using TmpProfilePath = ProfilePath::TmpProfilePath; |
| |
| using ::fmt::literals::operator""_format; // NOLINT |
| |
| ScopeGuard<std::function<void()>> ScopedSetLogger(android::base::LogFunction&& logger) { |
| android::base::LogFunction old_logger = android::base::SetLogger(std::move(logger)); |
| return make_scope_guard([old_logger = std::move(old_logger)]() mutable { |
| android::base::SetLogger(std::move(old_logger)); |
| }); |
| } |
| |
| void CheckContent(const std::string& path, const std::string& expected_content) { |
| std::string actual_content; |
| ASSERT_TRUE(ReadFileToString(path, &actual_content)); |
| EXPECT_EQ(actual_content, expected_content); |
| } |
| |
| void CheckOtherReadable(const std::string& path, bool expected_value) { |
| EXPECT_EQ((std::filesystem::status(path).permissions() & std::filesystem::perms::others_read) != |
| std::filesystem::perms::none, |
| expected_value); |
| } |
| |
| Result<std::vector<std::string>> GetFlagValues(ArrayRef<const std::string> args, |
| std::string_view flag) { |
| std::vector<std::string> values; |
| for (const std::string& arg : args) { |
| std::string_view value(arg); |
| if (android::base::ConsumePrefix(&value, flag)) { |
| values.emplace_back(value); |
| } |
| } |
| if (values.empty()) { |
| return Errorf("Flag '{}' not found", flag); |
| } |
| return values; |
| } |
| |
| Result<std::string> GetFlagValue(ArrayRef<const std::string> args, std::string_view flag) { |
| std::vector<std::string> flag_values = OR_RETURN(GetFlagValues(args, flag)); |
| if (flag_values.size() > 1) { |
| return Errorf("Duplicate flag '{}'", flag); |
| } |
| return flag_values[0]; |
| } |
| |
| void WriteToFdFlagImpl(const std::vector<std::string>& args, |
| std::string_view flag, |
| std::string_view content, |
| bool assume_empty) { |
| std::string value = OR_FAIL(GetFlagValue(ArrayRef<const std::string>(args), flag)); |
| ASSERT_NE(value, ""); |
| int fd; |
| ASSERT_TRUE(ParseInt(value, &fd)); |
| if (assume_empty) { |
| ASSERT_EQ(lseek(fd, /*offset=*/0, SEEK_CUR), 0); |
| } else { |
| ASSERT_EQ(ftruncate(fd, /*length=*/0), 0); |
| ASSERT_EQ(lseek(fd, /*offset=*/0, SEEK_SET), 0); |
| } |
| ASSERT_TRUE(WriteStringToFd(content, fd)); |
| } |
| |
| // Writes `content` to the FD specified by the `flag`. |
| ACTION_P(WriteToFdFlag, flag, content) { |
| WriteToFdFlagImpl(arg0, flag, content, /*assume_empty=*/true); |
| } |
| |
| // Clears any existing content and writes `content` to the FD specified by the `flag`. |
| ACTION_P(ClearAndWriteToFdFlag, flag, content) { |
| WriteToFdFlagImpl(arg0, flag, content, /*assume_empty=*/false); |
| } |
| |
| // Matches a flag that starts with `flag` and whose value matches `matcher`. |
| MATCHER_P2(Flag, flag, matcher, "") { |
| std::string_view value(arg); |
| if (!android::base::ConsumePrefix(&value, flag)) { |
| return false; |
| } |
| return ExplainMatchResult(matcher, std::string(value), result_listener); |
| } |
| |
| // Matches a flag that starts with `flag` and whose value is a colon-separated list that matches |
| // `matcher`. The matcher acts on an `std::vector<std::string>` of the split list argument. |
| MATCHER_P2(ListFlag, flag, matcher, "") { |
| return ExplainMatchResult( |
| Flag(flag, ResultOf(std::bind(Split, std::placeholders::_1, ":"), matcher)), |
| arg, |
| result_listener); |
| } |
| |
| // Matches an FD of a file whose path matches `matcher`. |
| MATCHER_P(FdOf, matcher, "") { |
| std::string proc_path = "/proc/self/fd/{}"_format(arg); |
| char path[PATH_MAX]; |
| ssize_t len = readlink(proc_path.c_str(), path, sizeof(path)); |
| if (len < 0) { |
| return false; |
| } |
| return ExplainMatchResult(matcher, std::string(path, static_cast<size_t>(len)), result_listener); |
| } |
| |
| // Matches an FD of a file whose content matches `matcher`. |
| MATCHER_P(FdHasContent, matcher, "") { |
| int fd; |
| if (!ParseInt(arg, &fd)) { |
| return false; |
| } |
| std::string actual_content; |
| if (!ReadFdToString(fd, &actual_content)) { |
| return false; |
| } |
| return ExplainMatchResult(matcher, actual_content, result_listener); |
| } |
| |
| template <typename T, typename U> |
| Result<std::pair<ArrayRef<const T>, ArrayRef<const T>>> SplitBy(const std::vector<T>& list, |
| const U& separator) { |
| auto it = std::find(list.begin(), list.end(), separator); |
| if (it == list.end()) { |
| return Errorf("'{}' not found", separator); |
| } |
| size_t pos = it - list.begin(); |
| return std::make_pair(ArrayRef<const T>(list).SubArray(0, pos), |
| ArrayRef<const T>(list).SubArray(pos + 1)); |
| } |
| |
| // Matches a container that, when split by `separator`, the first part matches `head_matcher`, and |
| // the second part matches `tail_matcher`. |
| MATCHER_P3(WhenSplitBy, separator, head_matcher, tail_matcher, "") { |
| auto [head, tail] = OR_MISMATCH(SplitBy(arg, separator)); |
| return ExplainMatchResult(head_matcher, head, result_listener) && |
| ExplainMatchResult(tail_matcher, tail, result_listener); |
| } |
| |
| MATCHER_P(HasKeepFdsForImpl, fd_flags, "") { |
| auto [head, tail] = OR_MISMATCH(SplitBy(arg, "--")); |
| std::string keep_fds_value = OR_MISMATCH(GetFlagValue(head, "--keep-fds=")); |
| std::vector<std::string> keep_fds = Split(keep_fds_value, ":"); |
| std::vector<std::string> fd_flag_values; |
| for (std::string_view fd_flag : fd_flags) { |
| for (const std::string& fd_flag_value : OR_MISMATCH(GetFlagValues(tail, fd_flag))) { |
| for (std::string& fd : Split(fd_flag_value, ":")) { |
| fd_flag_values.push_back(std::move(fd)); |
| } |
| } |
| } |
| return ExplainMatchResult(UnorderedElementsAreArray(fd_flag_values), keep_fds, result_listener); |
| } |
| |
| // Matches an argument list that has the "--keep-fds=" flag before "--", whose value is a |
| // semicolon-separated list that contains exactly the values of the given flags after "--". |
| // |
| // E.g., if the flags after "--" are "--foo=1", "--bar=2:3", "--baz=4", "--baz=5", and the matcher |
| // is `HasKeepFdsFor("--foo=", "--bar=", "--baz=")`, then it requires the "--keep-fds=" flag before |
| // "--" to contain exactly 1, 2, 3, 4, and 5. |
| template <typename... Args> |
| auto HasKeepFdsFor(Args&&... args) { |
| std::vector<std::string_view> fd_flags; |
| Append(fd_flags, std::forward<Args>(args)...); |
| return HasKeepFdsForImpl(fd_flags); |
| } |
| |
| class MockSystemProperties : public tools::SystemProperties { |
| public: |
| MOCK_METHOD(std::string, GetProperty, (const std::string& key), (const, override)); |
| }; |
| |
| class MockExecUtils : public ExecUtils { |
| public: |
| // A workaround to avoid MOCK_METHOD on a method with an `std::string*` parameter, which will lead |
| // to a conflict between gmock and android-base/logging.h (b/132668253). |
| ExecResult ExecAndReturnResult(const std::vector<std::string>& arg_vector, |
| int, |
| const ExecCallbacks& callbacks, |
| ProcessStat* stat, |
| std::string*) const override { |
| Result<int> code = DoExecAndReturnCode(arg_vector, callbacks, stat); |
| if (code.ok()) { |
| return {.status = ExecResult::kExited, .exit_code = code.value()}; |
| } |
| return {.status = ExecResult::kUnknown}; |
| } |
| |
| MOCK_METHOD(Result<int>, |
| DoExecAndReturnCode, |
| (const std::vector<std::string>& arg_vector, |
| const ExecCallbacks& callbacks, |
| ProcessStat* stat), |
| (const)); |
| }; |
| |
| class ArtdTest : public CommonArtTest { |
| protected: |
| void SetUp() override { |
| CommonArtTest::SetUp(); |
| auto mock_props = std::make_unique<MockSystemProperties>(); |
| mock_props_ = mock_props.get(); |
| EXPECT_CALL(*mock_props_, GetProperty).Times(AnyNumber()).WillRepeatedly(Return("")); |
| auto mock_exec_utils = std::make_unique<MockExecUtils>(); |
| mock_exec_utils_ = mock_exec_utils.get(); |
| artd_ = ndk::SharedRefBase::make<Artd>(std::move(mock_props), |
| std::move(mock_exec_utils), |
| mock_kill_.AsStdFunction(), |
| mock_fstat_.AsStdFunction()); |
| scratch_dir_ = std::make_unique<ScratchDir>(); |
| scratch_path_ = scratch_dir_->GetPath(); |
| // Remove the trailing '/'; |
| scratch_path_.resize(scratch_path_.length() - 1); |
| |
| ON_CALL(mock_fstat_, Call).WillByDefault(fstat); |
| |
| // Use an arbitrary existing directory as ART root. |
| art_root_ = scratch_path_ + "/com.android.art"; |
| std::filesystem::create_directories(art_root_); |
| setenv("ANDROID_ART_ROOT", art_root_.c_str(), /*overwrite=*/1); |
| |
| // Use an arbitrary existing directory as Android data. |
| android_data_ = scratch_path_ + "/data"; |
| std::filesystem::create_directories(android_data_); |
| setenv("ANDROID_DATA", android_data_.c_str(), /*overwrite=*/1); |
| |
| // Use an arbitrary existing directory as Android expand. |
| android_expand_ = scratch_path_ + "/mnt/expand"; |
| std::filesystem::create_directories(android_expand_); |
| setenv("ANDROID_EXPAND", android_expand_.c_str(), /*overwrite=*/1); |
| |
| dex_file_ = scratch_path_ + "/a/b.apk"; |
| isa_ = "arm64"; |
| artifacts_path_ = ArtifactsPath{ |
| .dexPath = dex_file_, |
| .isa = isa_, |
| .isInDalvikCache = false, |
| }; |
| struct stat st; |
| ASSERT_EQ(stat(scratch_path_.c_str(), &st), 0); |
| output_artifacts_ = OutputArtifacts{ |
| .artifactsPath = artifacts_path_, |
| .permissionSettings = |
| OutputArtifacts::PermissionSettings{ |
| .dirFsPermission = |
| FsPermission{ |
| .uid = static_cast<int32_t>(st.st_uid), |
| .gid = static_cast<int32_t>(st.st_gid), |
| .isOtherReadable = true, |
| .isOtherExecutable = true, |
| }, |
| .fileFsPermission = |
| FsPermission{ |
| .uid = static_cast<int32_t>(st.st_uid), |
| .gid = static_cast<int32_t>(st.st_gid), |
| .isOtherReadable = true, |
| }, |
| }, |
| }; |
| clc_1_ = GetTestDexFileName("Main"); |
| clc_2_ = GetTestDexFileName("Nested"); |
| class_loader_context_ = "PCL[{}:{}]"_format(clc_1_, clc_2_); |
| compiler_filter_ = "speed"; |
| TmpProfilePath tmp_profile_path{ |
| .finalPath = |
| PrimaryRefProfilePath{.packageName = "com.android.foo", .profileName = "primary"}, |
| .id = "12345"}; |
| profile_path_ = tmp_profile_path; |
| vdex_path_ = artifacts_path_; |
| dm_path_ = DexMetadataPath{.dexPath = dex_file_}; |
| std::filesystem::create_directories( |
| std::filesystem::path(OR_FATAL(BuildFinalProfilePath(tmp_profile_path))).parent_path()); |
| } |
| |
| void TearDown() override { |
| scratch_dir_.reset(); |
| CommonArtTest::TearDown(); |
| } |
| |
| void RunDexopt(binder_exception_t expected_status = EX_NONE, |
| Matcher<ArtdDexoptResult> aidl_return_matcher = Field(&ArtdDexoptResult::cancelled, |
| false), |
| std::shared_ptr<IArtdCancellationSignal> cancellation_signal = nullptr) { |
| RunDexopt(Property(&ndk::ScopedAStatus::getExceptionCode, expected_status), |
| std::move(aidl_return_matcher), |
| cancellation_signal); |
| } |
| |
| void RunDexopt(Matcher<ndk::ScopedAStatus> status_matcher, |
| Matcher<ArtdDexoptResult> aidl_return_matcher = Field(&ArtdDexoptResult::cancelled, |
| false), |
| std::shared_ptr<IArtdCancellationSignal> cancellation_signal = nullptr) { |
| InitFilesBeforeDexopt(); |
| if (cancellation_signal == nullptr) { |
| ASSERT_TRUE(artd_->createCancellationSignal(&cancellation_signal).isOk()); |
| } |
| ArtdDexoptResult aidl_return; |
| ndk::ScopedAStatus status = artd_->dexopt(output_artifacts_, |
| dex_file_, |
| isa_, |
| class_loader_context_, |
| compiler_filter_, |
| profile_path_, |
| vdex_path_, |
| dm_path_, |
| priority_class_, |
| dexopt_options_, |
| cancellation_signal, |
| &aidl_return); |
| ASSERT_THAT(status, std::move(status_matcher)) << status.getMessage(); |
| if (status.isOk()) { |
| ASSERT_THAT(aidl_return, std::move(aidl_return_matcher)); |
| } |
| } |
| |
| void CreateFile(const std::string& filename, const std::string& content = "") { |
| std::filesystem::path path(filename); |
| std::filesystem::create_directories(path.parent_path()); |
| ASSERT_TRUE(WriteStringToFile(content, filename)); |
| } |
| |
| std::shared_ptr<Artd> artd_; |
| std::unique_ptr<ScratchDir> scratch_dir_; |
| std::string scratch_path_; |
| std::string art_root_; |
| std::string android_data_; |
| std::string android_expand_; |
| MockFunction<android::base::LogFunction> mock_logger_; |
| ScopedUnsetEnvironmentVariable art_root_env_ = ScopedUnsetEnvironmentVariable("ANDROID_ART_ROOT"); |
| ScopedUnsetEnvironmentVariable android_data_env_ = ScopedUnsetEnvironmentVariable("ANDROID_DATA"); |
| ScopedUnsetEnvironmentVariable android_expand_env_ = |
| ScopedUnsetEnvironmentVariable("ANDROID_EXPAND"); |
| MockSystemProperties* mock_props_; |
| MockExecUtils* mock_exec_utils_; |
| MockFunction<int(pid_t, int)> mock_kill_; |
| MockFunction<int(int, struct stat*)> mock_fstat_; |
| |
| std::string dex_file_; |
| std::string isa_; |
| ArtifactsPath artifacts_path_; |
| OutputArtifacts output_artifacts_; |
| std::string clc_1_; |
| std::string clc_2_; |
| std::optional<std::string> class_loader_context_; |
| std::string compiler_filter_; |
| std::optional<VdexPath> vdex_path_; |
| std::optional<DexMetadataPath> dm_path_; |
| PriorityClass priority_class_ = PriorityClass::BACKGROUND; |
| DexoptOptions dexopt_options_; |
| std::optional<ProfilePath> profile_path_; |
| bool dex_file_other_readable_ = true; |
| bool profile_other_readable_ = true; |
| |
| private: |
| void InitFilesBeforeDexopt() { |
| // Required files. |
| CreateFile(dex_file_); |
| std::filesystem::permissions(dex_file_, |
| std::filesystem::perms::others_read, |
| dex_file_other_readable_ ? std::filesystem::perm_options::add : |
| std::filesystem::perm_options::remove); |
| |
| // Optional files. |
| if (vdex_path_.has_value()) { |
| CreateFile(OR_FATAL(BuildVdexPath(vdex_path_.value())), "old_vdex"); |
| } |
| if (dm_path_.has_value()) { |
| CreateFile(OR_FATAL(BuildDexMetadataPath(dm_path_.value()))); |
| } |
| if (profile_path_.has_value()) { |
| std::string path = OR_FATAL(BuildProfileOrDmPath(profile_path_.value())); |
| CreateFile(path); |
| std::filesystem::permissions(path, |
| std::filesystem::perms::others_read, |
| profile_other_readable_ ? std::filesystem::perm_options::add : |
| std::filesystem::perm_options::remove); |
| } |
| |
| // Files to be replaced. |
| std::string oat_path = OR_FATAL(BuildOatPath(artifacts_path_)); |
| CreateFile(oat_path, "old_oat"); |
| CreateFile(OatPathToVdexPath(oat_path), "old_vdex"); |
| CreateFile(OatPathToArtPath(oat_path), "old_art"); |
| } |
| }; |
| |
| TEST_F(ArtdTest, ConstantsAreInSync) { EXPECT_EQ(ArtConstants::REASON_VDEX, kReasonVdex); } |
| |
| TEST_F(ArtdTest, isAlive) { |
| bool result = false; |
| artd_->isAlive(&result); |
| EXPECT_TRUE(result); |
| } |
| |
| TEST_F(ArtdTest, deleteArtifacts) { |
| std::string oat_dir = scratch_path_ + "/a/oat/arm64"; |
| std::filesystem::create_directories(oat_dir); |
| ASSERT_TRUE(WriteStringToFile("abcd", oat_dir + "/b.odex")); // 4 bytes. |
| ASSERT_TRUE(WriteStringToFile("ab", oat_dir + "/b.vdex")); // 2 bytes. |
| ASSERT_TRUE(WriteStringToFile("a", oat_dir + "/b.art")); // 1 byte. |
| |
| int64_t result = -1; |
| EXPECT_TRUE(artd_->deleteArtifacts(artifacts_path_, &result).isOk()); |
| EXPECT_EQ(result, 4 + 2 + 1); |
| |
| EXPECT_FALSE(std::filesystem::exists(oat_dir + "/b.odex")); |
| EXPECT_FALSE(std::filesystem::exists(oat_dir + "/b.vdex")); |
| EXPECT_FALSE(std::filesystem::exists(oat_dir + "/b.art")); |
| } |
| |
| TEST_F(ArtdTest, deleteArtifactsMissingFile) { |
| // Missing VDEX file. |
| std::string oat_dir = android_data_ + "/dalvik-cache/arm64"; |
| std::filesystem::create_directories(oat_dir); |
| ASSERT_TRUE(WriteStringToFile("abcd", oat_dir + "/a@b.apk@classes.dex")); // 4 bytes. |
| ASSERT_TRUE(WriteStringToFile("a", oat_dir + "/a@b.apk@classes.art")); // 1 byte. |
| |
| auto scoped_set_logger = ScopedSetLogger(mock_logger_.AsStdFunction()); |
| EXPECT_CALL(mock_logger_, Call(_, _, _, _, _, HasSubstr("Failed to get the file size"))).Times(0); |
| |
| int64_t result = -1; |
| EXPECT_TRUE(artd_ |
| ->deleteArtifacts( |
| ArtifactsPath{ |
| .dexPath = "/a/b.apk", |
| .isa = "arm64", |
| .isInDalvikCache = true, |
| }, |
| &result) |
| .isOk()); |
| EXPECT_EQ(result, 4 + 1); |
| |
| EXPECT_FALSE(std::filesystem::exists(oat_dir + "/a@b.apk@classes.dex")); |
| EXPECT_FALSE(std::filesystem::exists(oat_dir + "/a@b.apk@classes.art")); |
| } |
| |
| TEST_F(ArtdTest, deleteArtifactsNoFile) { |
| auto scoped_set_logger = ScopedSetLogger(mock_logger_.AsStdFunction()); |
| EXPECT_CALL(mock_logger_, Call(_, _, _, _, _, HasSubstr("Failed to get the file size"))).Times(0); |
| |
| int64_t result = -1; |
| EXPECT_TRUE(artd_->deleteArtifacts(artifacts_path_, &result).isOk()); |
| EXPECT_EQ(result, 0); |
| } |
| |
| TEST_F(ArtdTest, deleteArtifactsPermissionDenied) { |
| std::string oat_dir = scratch_path_ + "/a/oat/arm64"; |
| std::filesystem::create_directories(oat_dir); |
| ASSERT_TRUE(WriteStringToFile("abcd", oat_dir + "/b.odex")); // 4 bytes. |
| ASSERT_TRUE(WriteStringToFile("ab", oat_dir + "/b.vdex")); // 2 bytes. |
| ASSERT_TRUE(WriteStringToFile("a", oat_dir + "/b.art")); // 1 byte. |
| |
| auto scoped_set_logger = ScopedSetLogger(mock_logger_.AsStdFunction()); |
| EXPECT_CALL(mock_logger_, Call(_, _, _, _, _, HasSubstr("Failed to get the file size"))).Times(3); |
| |
| auto scoped_inaccessible = ScopedInaccessible(oat_dir); |
| auto scoped_unroot = ScopedUnroot(); |
| |
| int64_t result = -1; |
| EXPECT_TRUE(artd_->deleteArtifacts(artifacts_path_, &result).isOk()); |
| EXPECT_EQ(result, 0); |
| } |
| |
| TEST_F(ArtdTest, deleteArtifactsFileIsDir) { |
| // VDEX file is a directory. |
| std::string oat_dir = scratch_path_ + "/a/oat/arm64"; |
| std::filesystem::create_directories(oat_dir); |
| std::filesystem::create_directories(oat_dir + "/b.vdex"); |
| ASSERT_TRUE(WriteStringToFile("abcd", oat_dir + "/b.odex")); // 4 bytes. |
| ASSERT_TRUE(WriteStringToFile("a", oat_dir + "/b.art")); // 1 byte. |
| |
| auto scoped_set_logger = ScopedSetLogger(mock_logger_.AsStdFunction()); |
| EXPECT_CALL(mock_logger_, |
| Call(_, _, _, _, _, ContainsRegex(R"re(Failed to get the file size.*b\.vdex)re"))) |
| .Times(1); |
| |
| int64_t result = -1; |
| EXPECT_TRUE(artd_->deleteArtifacts(artifacts_path_, &result).isOk()); |
| EXPECT_EQ(result, 4 + 1); |
| |
| // The directory is kept because getting the file size failed. |
| EXPECT_FALSE(std::filesystem::exists(oat_dir + "/b.odex")); |
| EXPECT_TRUE(std::filesystem::exists(oat_dir + "/b.vdex")); |
| EXPECT_FALSE(std::filesystem::exists(oat_dir + "/b.art")); |
| } |
| |
| TEST_F(ArtdTest, dexopt) { |
| dexopt_options_.generateAppImage = true; |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| AllOf(WhenSplitBy( |
| "--", |
| AllOf(Contains(art_root_ + "/bin/art_exec"), Contains("--drop-capabilities")), |
| AllOf(Contains(art_root_ + "/bin/dex2oat32"), |
| Contains(Flag("--zip-fd=", FdOf(dex_file_))), |
| Contains(Flag("--zip-location=", dex_file_)), |
| Contains(Flag("--oat-location=", scratch_path_ + "/a/oat/arm64/b.odex")), |
| Contains(Flag("--instruction-set=", "arm64")), |
| Contains(Flag("--compiler-filter=", "speed")), |
| Contains(Flag( |
| "--profile-file-fd=", |
| FdOf(android_data_ + |
| "/misc/profiles/ref/com.android.foo/primary.prof.12345.tmp"))), |
| Contains(Flag("--input-vdex-fd=", |
| FdOf(scratch_path_ + "/a/oat/arm64/b.vdex"))), |
| Contains(Flag("--dm-fd=", FdOf(scratch_path_ + "/a/b.dm"))))), |
| HasKeepFdsFor("--zip-fd=", |
| "--profile-file-fd=", |
| "--input-vdex-fd=", |
| "--dm-fd=", |
| "--oat-fd=", |
| "--output-vdex-fd=", |
| "--app-image-fd=", |
| "--class-loader-context-fds=", |
| "--swap-fd=")), |
| _, |
| _)) |
| .WillOnce(DoAll(WithArg<0>(WriteToFdFlag("--oat-fd=", "oat")), |
| WithArg<0>(WriteToFdFlag("--output-vdex-fd=", "vdex")), |
| WithArg<0>(WriteToFdFlag("--app-image-fd=", "art")), |
| SetArgPointee<2>(ProcessStat{.wall_time_ms = 100, .cpu_time_ms = 400}), |
| Return(0))); |
| RunDexopt( |
| EX_NONE, |
| AllOf(Field(&ArtdDexoptResult::cancelled, false), |
| Field(&ArtdDexoptResult::wallTimeMs, 100), |
| Field(&ArtdDexoptResult::cpuTimeMs, 400), |
| Field(&ArtdDexoptResult::sizeBytes, strlen("art") + strlen("oat") + strlen("vdex")), |
| Field(&ArtdDexoptResult::sizeBeforeBytes, |
| strlen("old_art") + strlen("old_oat") + strlen("old_vdex")))); |
| |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.odex", "oat"); |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.vdex", "vdex"); |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.art", "art"); |
| CheckOtherReadable(scratch_path_ + "/a/oat/arm64/b.odex", true); |
| CheckOtherReadable(scratch_path_ + "/a/oat/arm64/b.vdex", true); |
| CheckOtherReadable(scratch_path_ + "/a/oat/arm64/b.art", true); |
| } |
| |
| TEST_F(ArtdTest, dexoptClassLoaderContext) { |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy("--", |
| _, |
| AllOf(Contains(ListFlag("--class-loader-context-fds=", |
| ElementsAre(FdOf(clc_1_), FdOf(clc_2_)))), |
| Contains(Flag("--class-loader-context=", class_loader_context_)), |
| Contains(Flag("--classpath-dir=", scratch_path_ + "/a")))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptClassLoaderContextNull) { |
| class_loader_context_ = std::nullopt; |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode(WhenSplitBy("--", |
| _, |
| AllOf(Not(Contains(Flag("--class-loader-context-fds=", _))), |
| Not(Contains(Flag("--class-loader-context=", _))), |
| Not(Contains(Flag("--classpath-dir=", _))))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptNoOptionalInputFiles) { |
| profile_path_ = std::nullopt; |
| vdex_path_ = std::nullopt; |
| dm_path_ = std::nullopt; |
| |
| EXPECT_CALL(*mock_exec_utils_, |
| DoExecAndReturnCode(WhenSplitBy("--", |
| _, |
| AllOf(Not(Contains(Flag("--profile-file-fd=", _))), |
| Not(Contains(Flag("--input-vdex-fd=", _))), |
| Not(Contains(Flag("--dm-fd=", _))))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptPriorityClassBoot) { |
| priority_class_ = PriorityClass::BOOT; |
| EXPECT_CALL(*mock_exec_utils_, |
| DoExecAndReturnCode(WhenSplitBy("--", |
| AllOf(Not(Contains(Flag("--set-task-profile=", _))), |
| Not(Contains(Flag("--set-priority=", _)))), |
| Contains(Flag("--compact-dex-level=", "none"))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptPriorityClassInteractive) { |
| priority_class_ = PriorityClass::INTERACTIVE; |
| EXPECT_CALL(*mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy("--", |
| AllOf(Contains(Flag("--set-task-profile=", "Dex2OatBootComplete")), |
| Contains(Flag("--set-priority=", "background"))), |
| Contains(Flag("--compact-dex-level=", "none"))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptPriorityClassInteractiveFast) { |
| priority_class_ = PriorityClass::INTERACTIVE_FAST; |
| EXPECT_CALL(*mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy("--", |
| AllOf(Contains(Flag("--set-task-profile=", "Dex2OatBootComplete")), |
| Contains(Flag("--set-priority=", "background"))), |
| Contains(Flag("--compact-dex-level=", "none"))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptPriorityClassBackground) { |
| priority_class_ = PriorityClass::BACKGROUND; |
| EXPECT_CALL(*mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy("--", |
| AllOf(Contains(Flag("--set-task-profile=", "Dex2OatBackground")), |
| Contains(Flag("--set-priority=", "background"))), |
| Not(Contains(Flag("--compact-dex-level=", _)))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptDexoptOptions) { |
| dexopt_options_ = DexoptOptions{ |
| .compilationReason = "install", |
| .targetSdkVersion = 123, |
| .debuggable = false, |
| .generateAppImage = false, |
| .hiddenApiPolicyEnabled = false, |
| .comments = "my-comments", |
| }; |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode(WhenSplitBy("--", |
| _, |
| AllOf(Contains(Flag("--compilation-reason=", "install")), |
| Contains(Flag("-Xtarget-sdk-version:", "123")), |
| Not(Contains("--debuggable")), |
| Not(Contains(Flag("--app-image-fd=", _))), |
| Not(Contains(Flag("-Xhidden-api-policy:", _))), |
| Contains(Flag("--comments=", "my-comments")))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| |
| // `sizeBeforeBytes` should include the size of the old ART file even if no new ART file is |
| // generated. |
| RunDexopt(EX_NONE, |
| Field(&ArtdDexoptResult::sizeBeforeBytes, |
| strlen("old_art") + strlen("old_oat") + strlen("old_vdex"))); |
| } |
| |
| TEST_F(ArtdTest, dexoptDexoptOptions2) { |
| dexopt_options_ = DexoptOptions{ |
| .compilationReason = "bg-dexopt", |
| .targetSdkVersion = 456, |
| .debuggable = true, |
| .generateAppImage = true, |
| .hiddenApiPolicyEnabled = true, |
| }; |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode(WhenSplitBy("--", |
| _, |
| AllOf(Contains(Flag("--compilation-reason=", "bg-dexopt")), |
| Contains(Flag("-Xtarget-sdk-version:", "456")), |
| Contains("--debuggable"), |
| Contains(Flag("--app-image-fd=", _)), |
| Contains(Flag("-Xhidden-api-policy:", "enabled")))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptDefaultFlagsWhenNoSystemProps) { |
| dexopt_options_.generateAppImage = true; |
| |
| EXPECT_CALL(*mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy("--", |
| _, |
| AllOf(Contains(Flag("--swap-fd=", FdOf(_))), |
| Not(Contains(Flag("--instruction-set-features=", _))), |
| Not(Contains(Flag("--instruction-set-variant=", _))), |
| Not(Contains(Flag("--max-image-block-size=", _))), |
| Not(Contains(Flag("--very-large-app-threshold=", _))), |
| Not(Contains(Flag("--resolve-startup-const-strings=", _))), |
| Not(Contains("--generate-debug-info")), |
| Not(Contains("--generate-mini-debug-info")), |
| Contains("-Xdeny-art-apex-data-files"), |
| Not(Contains(Flag("--cpu-set=", _))), |
| Not(Contains(Flag("-j", _))), |
| Not(Contains(Flag("-Xms", _))), |
| Not(Contains(Flag("-Xmx", _))), |
| Not(Contains("--compile-individually")), |
| Not(Contains(Flag("--image-format=", _))), |
| Not(Contains("--force-jit-zygote")), |
| Not(Contains(Flag("--boot-image=", _))))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptFlagsFromSystemProps) { |
| dexopt_options_.generateAppImage = true; |
| |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.dex2oat-swap")).WillOnce(Return("0")); |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.isa.arm64.features")) |
| .WillOnce(Return("features")); |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.isa.arm64.variant")).WillOnce(Return("variant")); |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.dex2oat-max-image-block-size")) |
| .WillOnce(Return("size")); |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.dex2oat-very-large")) |
| .WillOnce(Return("threshold")); |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.dex2oat-resolve-startup-strings")) |
| .WillOnce(Return("strings")); |
| EXPECT_CALL(*mock_props_, GetProperty("debug.generate-debug-info")).WillOnce(Return("1")); |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.dex2oat-minidebuginfo")).WillOnce(Return("1")); |
| EXPECT_CALL(*mock_props_, GetProperty("odsign.verification.success")).WillOnce(Return("1")); |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.dex2oat-Xms")).WillOnce(Return("xms")); |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.dex2oat-Xmx")).WillOnce(Return("xmx")); |
| EXPECT_CALL(*mock_props_, GetProperty("ro.config.low_ram")).WillOnce(Return("1")); |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.appimageformat")).WillOnce(Return("imgfmt")); |
| EXPECT_CALL(*mock_props_, GetProperty("dalvik.vm.boot-image")).WillOnce(Return("boot-image")); |
| |
| EXPECT_CALL(*mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy("--", |
| _, |
| AllOf(Not(Contains(Flag("--swap-fd=", _))), |
| Contains(Flag("--instruction-set-features=", "features")), |
| Contains(Flag("--instruction-set-variant=", "variant")), |
| Contains(Flag("--max-image-block-size=", "size")), |
| Contains(Flag("--very-large-app-threshold=", "threshold")), |
| Contains(Flag("--resolve-startup-const-strings=", "strings")), |
| Contains("--generate-debug-info"), |
| Contains("--generate-mini-debug-info"), |
| Not(Contains("-Xdeny-art-apex-data-files")), |
| Contains(Flag("-Xms", "xms")), |
| Contains(Flag("-Xmx", "xmx")), |
| Contains("--compile-individually"), |
| Contains(Flag("--image-format=", "imgfmt")), |
| Not(Contains("--force-jit-zygote")), |
| Contains(Flag("--boot-image=", "boot-image")))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptFlagsForceJitZygote) { |
| EXPECT_CALL(*mock_props_, |
| GetProperty("persist.device_config.runtime_native_boot.profilebootclasspath")) |
| .WillOnce(Return("true")); |
| ON_CALL(*mock_props_, GetProperty("dalvik.vm.boot-image")).WillByDefault(Return("boot-image")); |
| |
| EXPECT_CALL(*mock_exec_utils_, |
| DoExecAndReturnCode(WhenSplitBy("--", |
| _, |
| AllOf(Contains("--force-jit-zygote"), |
| Not(Contains(Flag("--boot-image=", _))))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| static void SetDefaultResourceControlProps(MockSystemProperties* mock_props) { |
| EXPECT_CALL(*mock_props, GetProperty("dalvik.vm.dex2oat-cpu-set")).WillRepeatedly(Return("0,2")); |
| EXPECT_CALL(*mock_props, GetProperty("dalvik.vm.dex2oat-threads")).WillRepeatedly(Return("4")); |
| } |
| |
| TEST_F(ArtdTest, dexoptDefaultResourceControlBoot) { |
| SetDefaultResourceControlProps(mock_props_); |
| |
| // The default resource control properties don't apply to BOOT. |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy( |
| "--", _, AllOf(Not(Contains(Flag("--cpu-set=", _))), Contains(Not(Flag("-j", _))))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| priority_class_ = PriorityClass::BOOT; |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptDefaultResourceControlOther) { |
| SetDefaultResourceControlProps(mock_props_); |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy( |
| "--", _, AllOf(Contains(Flag("--cpu-set=", "0,2")), Contains(Flag("-j", "4")))), |
| _, |
| _)) |
| .Times(3) |
| .WillRepeatedly(Return(0)); |
| priority_class_ = PriorityClass::INTERACTIVE_FAST; |
| RunDexopt(); |
| priority_class_ = PriorityClass::INTERACTIVE; |
| RunDexopt(); |
| priority_class_ = PriorityClass::BACKGROUND; |
| RunDexopt(); |
| } |
| |
| static void SetAllResourceControlProps(MockSystemProperties* mock_props) { |
| EXPECT_CALL(*mock_props, GetProperty("dalvik.vm.dex2oat-cpu-set")).WillRepeatedly(Return("0,2")); |
| EXPECT_CALL(*mock_props, GetProperty("dalvik.vm.dex2oat-threads")).WillRepeatedly(Return("4")); |
| EXPECT_CALL(*mock_props, GetProperty("dalvik.vm.boot-dex2oat-cpu-set")) |
| .WillRepeatedly(Return("0,1,2,3")); |
| EXPECT_CALL(*mock_props, GetProperty("dalvik.vm.boot-dex2oat-threads")) |
| .WillRepeatedly(Return("8")); |
| EXPECT_CALL(*mock_props, GetProperty("dalvik.vm.restore-dex2oat-cpu-set")) |
| .WillRepeatedly(Return("0,2,3")); |
| EXPECT_CALL(*mock_props, GetProperty("dalvik.vm.restore-dex2oat-threads")) |
| .WillRepeatedly(Return("6")); |
| EXPECT_CALL(*mock_props, GetProperty("dalvik.vm.background-dex2oat-cpu-set")) |
| .WillRepeatedly(Return("0")); |
| EXPECT_CALL(*mock_props, GetProperty("dalvik.vm.background-dex2oat-threads")) |
| .WillRepeatedly(Return("2")); |
| } |
| |
| TEST_F(ArtdTest, dexoptAllResourceControlBoot) { |
| SetAllResourceControlProps(mock_props_); |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy( |
| "--", _, AllOf(Contains(Flag("--cpu-set=", "0,1,2,3")), Contains(Flag("-j", "8")))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| priority_class_ = PriorityClass::BOOT; |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptAllResourceControlInteractiveFast) { |
| SetAllResourceControlProps(mock_props_); |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy( |
| "--", _, AllOf(Contains(Flag("--cpu-set=", "0,2,3")), Contains(Flag("-j", "6")))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| priority_class_ = PriorityClass::INTERACTIVE_FAST; |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptAllResourceControlInteractive) { |
| SetAllResourceControlProps(mock_props_); |
| |
| // INTERACTIVE always uses the default resource control properties. |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy( |
| "--", _, AllOf(Contains(Flag("--cpu-set=", "0,2")), Contains(Flag("-j", "4")))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| priority_class_ = PriorityClass::INTERACTIVE; |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptAllResourceControlBackground) { |
| SetAllResourceControlProps(mock_props_); |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy("--", _, AllOf(Contains(Flag("--cpu-set=", "0")), Contains(Flag("-j", "2")))), |
| _, |
| _)) |
| .WillOnce(Return(0)); |
| priority_class_ = PriorityClass::BACKGROUND; |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, dexoptFailed) { |
| dexopt_options_.generateAppImage = true; |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)) |
| .WillOnce(DoAll(WithArg<0>(WriteToFdFlag("--oat-fd=", "new_oat")), |
| WithArg<0>(WriteToFdFlag("--output-vdex-fd=", "new_vdex")), |
| WithArg<0>(WriteToFdFlag("--app-image-fd=", "new_art")), |
| Return(1))); |
| RunDexopt(EX_SERVICE_SPECIFIC); |
| |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.odex", "old_oat"); |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.vdex", "old_vdex"); |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.art", "old_art"); |
| } |
| |
| TEST_F(ArtdTest, dexoptFailedToCommit) { |
| std::unique_ptr<ScopeGuard<std::function<void()>>> scoped_inaccessible; |
| std::unique_ptr<ScopeGuard<std::function<void()>>> scoped_unroot; |
| |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)) |
| .WillOnce(DoAll(WithArg<0>(WriteToFdFlag("--oat-fd=", "new_oat")), |
| WithArg<0>(WriteToFdFlag("--output-vdex-fd=", "new_vdex")), |
| [&](auto, auto, auto) { |
| scoped_inaccessible = std::make_unique<ScopeGuard<std::function<void()>>>( |
| ScopedInaccessible(scratch_path_ + "/a/oat/arm64")); |
| scoped_unroot = |
| std::make_unique<ScopeGuard<std::function<void()>>>(ScopedUnroot()); |
| return 0; |
| })); |
| |
| RunDexopt( |
| EX_SERVICE_SPECIFIC, |
| AllOf(Field(&ArtdDexoptResult::sizeBytes, 0), Field(&ArtdDexoptResult::sizeBeforeBytes, 0))); |
| } |
| |
| TEST_F(ArtdTest, dexoptCancelledBeforeDex2oat) { |
| std::shared_ptr<IArtdCancellationSignal> cancellation_signal; |
| ASSERT_TRUE(artd_->createCancellationSignal(&cancellation_signal).isOk()); |
| |
| constexpr pid_t kPid = 123; |
| |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)) |
| .WillOnce([&](auto, const ExecCallbacks& callbacks, auto) { |
| callbacks.on_start(kPid); |
| callbacks.on_end(kPid); |
| return Error(); |
| }); |
| EXPECT_CALL(mock_kill_, Call(kPid, SIGKILL)); |
| |
| cancellation_signal->cancel(); |
| |
| RunDexopt(EX_NONE, Field(&ArtdDexoptResult::cancelled, true), cancellation_signal); |
| |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.odex", "old_oat"); |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.vdex", "old_vdex"); |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.art", "old_art"); |
| } |
| |
| TEST_F(ArtdTest, dexoptCancelledDuringDex2oat) { |
| std::shared_ptr<IArtdCancellationSignal> cancellation_signal; |
| ASSERT_TRUE(artd_->createCancellationSignal(&cancellation_signal).isOk()); |
| |
| constexpr pid_t kPid = 123; |
| constexpr std::chrono::duration<int> kTimeout = std::chrono::seconds(1); |
| |
| std::condition_variable process_started_cv, process_killed_cv; |
| std::mutex mu; |
| |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)) |
| .WillOnce([&](auto, const ExecCallbacks& callbacks, auto) { |
| std::unique_lock<std::mutex> lock(mu); |
| // Step 2. |
| callbacks.on_start(kPid); |
| process_started_cv.notify_one(); |
| EXPECT_EQ(process_killed_cv.wait_for(lock, kTimeout), std::cv_status::no_timeout); |
| // Step 5. |
| callbacks.on_end(kPid); |
| return Error(); |
| }); |
| |
| EXPECT_CALL(mock_kill_, Call(kPid, SIGKILL)).WillOnce([&](auto, auto) { |
| // Step 4. |
| process_killed_cv.notify_one(); |
| return 0; |
| }); |
| |
| std::thread t; |
| { |
| std::unique_lock<std::mutex> lock(mu); |
| // Step 1. |
| t = std::thread([&] { |
| RunDexopt(EX_NONE, Field(&ArtdDexoptResult::cancelled, true), cancellation_signal); |
| }); |
| EXPECT_EQ(process_started_cv.wait_for(lock, kTimeout), std::cv_status::no_timeout); |
| // Step 3. |
| cancellation_signal->cancel(); |
| } |
| |
| t.join(); |
| |
| // Step 6. |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.odex", "old_oat"); |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.vdex", "old_vdex"); |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.art", "old_art"); |
| } |
| |
| TEST_F(ArtdTest, dexoptCancelledAfterDex2oat) { |
| std::shared_ptr<IArtdCancellationSignal> cancellation_signal; |
| ASSERT_TRUE(artd_->createCancellationSignal(&cancellation_signal).isOk()); |
| |
| constexpr pid_t kPid = 123; |
| |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)) |
| .WillOnce(DoAll(WithArg<0>(WriteToFdFlag("--oat-fd=", "new_oat")), |
| WithArg<0>(WriteToFdFlag("--output-vdex-fd=", "new_vdex")), |
| [&](auto, const ExecCallbacks& callbacks, auto) { |
| callbacks.on_start(kPid); |
| callbacks.on_end(kPid); |
| return 0; |
| })); |
| EXPECT_CALL(mock_kill_, Call).Times(0); |
| |
| RunDexopt(EX_NONE, Field(&ArtdDexoptResult::cancelled, false), cancellation_signal); |
| |
| // This signal should be ignored. |
| cancellation_signal->cancel(); |
| |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.odex", "new_oat"); |
| CheckContent(scratch_path_ + "/a/oat/arm64/b.vdex", "new_vdex"); |
| EXPECT_FALSE(std::filesystem::exists(scratch_path_ + "/a/oat/arm64/b.art")); |
| } |
| |
| TEST_F(ArtdTest, dexoptDexFileNotOtherReadable) { |
| dex_file_other_readable_ = false; |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).Times(0); |
| RunDexopt(AllOf(Property(&ndk::ScopedAStatus::getExceptionCode, EX_SERVICE_SPECIFIC), |
| Property(&ndk::ScopedAStatus::getMessage, |
| HasSubstr("Outputs cannot be other-readable because the dex file")))); |
| } |
| |
| TEST_F(ArtdTest, dexoptProfileNotOtherReadable) { |
| profile_other_readable_ = false; |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).Times(0); |
| RunDexopt(AllOf(Property(&ndk::ScopedAStatus::getExceptionCode, EX_SERVICE_SPECIFIC), |
| Property(&ndk::ScopedAStatus::getMessage, |
| HasSubstr("Outputs cannot be other-readable because the profile")))); |
| } |
| |
| TEST_F(ArtdTest, dexoptOutputNotOtherReadable) { |
| output_artifacts_.permissionSettings.fileFsPermission.isOtherReadable = false; |
| dex_file_other_readable_ = false; |
| profile_other_readable_ = false; |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).WillOnce(Return(0)); |
| RunDexopt(); |
| CheckOtherReadable(scratch_path_ + "/a/oat/arm64/b.odex", false); |
| CheckOtherReadable(scratch_path_ + "/a/oat/arm64/b.vdex", false); |
| } |
| |
| TEST_F(ArtdTest, dexoptUidMismatch) { |
| output_artifacts_.permissionSettings.fileFsPermission.uid = 12345; |
| output_artifacts_.permissionSettings.fileFsPermission.isOtherReadable = false; |
| dex_file_other_readable_ = false; |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).Times(0); |
| RunDexopt(AllOf(Property(&ndk::ScopedAStatus::getExceptionCode, EX_SERVICE_SPECIFIC), |
| Property(&ndk::ScopedAStatus::getMessage, |
| HasSubstr("Outputs' owner doesn't match the dex file")))); |
| } |
| |
| TEST_F(ArtdTest, dexoptGidMismatch) { |
| output_artifacts_.permissionSettings.fileFsPermission.gid = 12345; |
| output_artifacts_.permissionSettings.fileFsPermission.isOtherReadable = false; |
| dex_file_other_readable_ = false; |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).Times(0); |
| RunDexopt(AllOf(Property(&ndk::ScopedAStatus::getExceptionCode, EX_SERVICE_SPECIFIC), |
| Property(&ndk::ScopedAStatus::getMessage, |
| HasSubstr("Outputs' owner doesn't match the dex file")))); |
| } |
| |
| TEST_F(ArtdTest, dexoptGidMatchesUid) { |
| output_artifacts_.permissionSettings.fileFsPermission = { |
| .uid = 123, .gid = 123, .isOtherReadable = false}; |
| EXPECT_CALL(mock_fstat_, Call(_, _)).WillRepeatedly(fstat); // For profile. |
| EXPECT_CALL(mock_fstat_, Call(FdOf(dex_file_), _)) |
| .WillOnce(DoAll(SetArgPointee<1>((struct stat){ |
| .st_mode = S_IRUSR | S_IRGRP, .st_uid = 123, .st_gid = 456}), |
| Return(0))); |
| ON_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).WillByDefault(Return(0)); |
| // It's okay to fail on chown. This happens when the test is not run as root. |
| RunDexopt(AnyOf(Property(&ndk::ScopedAStatus::getExceptionCode, EX_NONE), |
| AllOf(Property(&ndk::ScopedAStatus::getExceptionCode, EX_SERVICE_SPECIFIC), |
| Property(&ndk::ScopedAStatus::getMessage, HasSubstr("Failed to chown"))))); |
| } |
| |
| TEST_F(ArtdTest, dexoptGidMatchesGid) { |
| output_artifacts_.permissionSettings.fileFsPermission = { |
| .uid = 123, .gid = 456, .isOtherReadable = false}; |
| EXPECT_CALL(mock_fstat_, Call(_, _)).WillRepeatedly(fstat); // For profile. |
| EXPECT_CALL(mock_fstat_, Call(FdOf(dex_file_), _)) |
| .WillOnce(DoAll(SetArgPointee<1>((struct stat){ |
| .st_mode = S_IRUSR | S_IRGRP, .st_uid = 123, .st_gid = 456}), |
| Return(0))); |
| ON_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).WillByDefault(Return(0)); |
| // It's okay to fail on chown. This happens when the test is not run as root. |
| RunDexopt(AnyOf(Property(&ndk::ScopedAStatus::getExceptionCode, EX_NONE), |
| AllOf(Property(&ndk::ScopedAStatus::getExceptionCode, EX_SERVICE_SPECIFIC), |
| Property(&ndk::ScopedAStatus::getMessage, HasSubstr("Failed to chown"))))); |
| } |
| |
| TEST_F(ArtdTest, dexoptUidGidChangeOk) { |
| // The dex file is other-readable, so we don't check uid and gid. |
| output_artifacts_.permissionSettings.fileFsPermission = { |
| .uid = 12345, .gid = 12345, .isOtherReadable = false}; |
| ON_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).WillByDefault(Return(0)); |
| // It's okay to fail on chown. This happens when the test is not run as root. |
| RunDexopt(AnyOf(Property(&ndk::ScopedAStatus::getExceptionCode, EX_NONE), |
| AllOf(Property(&ndk::ScopedAStatus::getExceptionCode, EX_SERVICE_SPECIFIC), |
| Property(&ndk::ScopedAStatus::getMessage, HasSubstr("Failed to chown"))))); |
| } |
| |
| TEST_F(ArtdTest, dexoptNoUidGidChange) { |
| output_artifacts_.permissionSettings.fileFsPermission = { |
| .uid = -1, .gid = -1, .isOtherReadable = false}; |
| dex_file_other_readable_ = false; |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).WillOnce(Return(0)); |
| RunDexopt(); |
| } |
| |
| TEST_F(ArtdTest, isProfileUsable) { |
| std::string profile_file = OR_FATAL(BuildProfileOrDmPath(profile_path_.value())); |
| CreateFile(profile_file); |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| AllOf(WhenSplitBy( |
| "--", |
| AllOf(Contains(art_root_ + "/bin/art_exec"), Contains("--drop-capabilities")), |
| AllOf(Contains(art_root_ + "/bin/profman"), |
| Contains(Flag("--reference-profile-file-fd=", FdOf(profile_file))), |
| Contains(Flag("--apk-fd=", FdOf(dex_file_))))), |
| HasKeepFdsFor("--reference-profile-file-fd=", "--apk-fd=")), |
| _, |
| _)) |
| .WillOnce(Return(ProfmanResult::kSkipCompilationSmallDelta)); |
| |
| bool result; |
| EXPECT_TRUE(artd_->isProfileUsable(profile_path_.value(), dex_file_, &result).isOk()); |
| EXPECT_TRUE(result); |
| } |
| |
| TEST_F(ArtdTest, isProfileUsableFalse) { |
| std::string profile_file = OR_FATAL(BuildProfileOrDmPath(profile_path_.value())); |
| CreateFile(profile_file); |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)) |
| .WillOnce(Return(ProfmanResult::kSkipCompilationEmptyProfiles)); |
| |
| bool result; |
| EXPECT_TRUE(artd_->isProfileUsable(profile_path_.value(), dex_file_, &result).isOk()); |
| EXPECT_FALSE(result); |
| } |
| |
| TEST_F(ArtdTest, isProfileUsableNotFound) { |
| CreateFile(dex_file_); |
| |
| bool result; |
| EXPECT_TRUE(artd_->isProfileUsable(profile_path_.value(), dex_file_, &result).isOk()); |
| EXPECT_FALSE(result); |
| } |
| |
| TEST_F(ArtdTest, isProfileUsableFailed) { |
| std::string profile_file = OR_FATAL(BuildProfileOrDmPath(profile_path_.value())); |
| CreateFile(profile_file); |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).WillOnce(Return(100)); |
| |
| bool result; |
| ndk::ScopedAStatus status = artd_->isProfileUsable(profile_path_.value(), dex_file_, &result); |
| |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC); |
| EXPECT_THAT(status.getMessage(), HasSubstr("profman returned an unexpected code: 100")); |
| } |
| |
| TEST_F(ArtdTest, copyAndRewriteProfile) { |
| const TmpProfilePath& src = profile_path_->get<ProfilePath::tmpProfilePath>(); |
| std::string src_file = OR_FATAL(BuildTmpProfilePath(src)); |
| CreateFile(src_file, "abc"); |
| OutputProfile dst{.profilePath = src, .fsPermission = FsPermission{.uid = -1, .gid = -1}}; |
| dst.profilePath.id = ""; |
| dst.profilePath.tmpPath = ""; |
| |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| AllOf(WhenSplitBy( |
| "--", |
| AllOf(Contains(art_root_ + "/bin/art_exec"), Contains("--drop-capabilities")), |
| AllOf(Contains(art_root_ + "/bin/profman"), |
| Contains("--copy-and-update-profile-key"), |
| Contains(Flag("--profile-file-fd=", FdOf(src_file))), |
| Contains(Flag("--apk-fd=", FdOf(dex_file_))))), |
| HasKeepFdsFor("--profile-file-fd=", "--reference-profile-file-fd=", "--apk-fd=")), |
| _, |
| _)) |
| .WillOnce(DoAll(WithArg<0>(WriteToFdFlag("--reference-profile-file-fd=", "def")), |
| Return(ProfmanResult::kCopyAndUpdateSuccess))); |
| |
| bool result; |
| EXPECT_TRUE(artd_->copyAndRewriteProfile(src, &dst, dex_file_, &result).isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_THAT(dst.profilePath.id, Not(IsEmpty())); |
| std::string real_path = OR_FATAL(BuildTmpProfilePath(dst.profilePath)); |
| EXPECT_EQ(dst.profilePath.tmpPath, real_path); |
| CheckContent(real_path, "def"); |
| } |
| |
| TEST_F(ArtdTest, copyAndRewriteProfileFalse) { |
| const TmpProfilePath& src = profile_path_->get<ProfilePath::tmpProfilePath>(); |
| std::string src_file = OR_FATAL(BuildTmpProfilePath(src)); |
| CreateFile(src_file, "abc"); |
| OutputProfile dst{.profilePath = src, .fsPermission = FsPermission{.uid = -1, .gid = -1}}; |
| dst.profilePath.id = ""; |
| dst.profilePath.tmpPath = ""; |
| |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)) |
| .WillOnce(Return(ProfmanResult::kCopyAndUpdateNoMatch)); |
| |
| bool result; |
| EXPECT_TRUE(artd_->copyAndRewriteProfile(src, &dst, dex_file_, &result).isOk()); |
| EXPECT_FALSE(result); |
| EXPECT_THAT(dst.profilePath.id, IsEmpty()); |
| EXPECT_THAT(dst.profilePath.tmpPath, IsEmpty()); |
| } |
| |
| TEST_F(ArtdTest, copyAndRewriteProfileNotFound) { |
| CreateFile(dex_file_); |
| |
| const TmpProfilePath& src = profile_path_->get<ProfilePath::tmpProfilePath>(); |
| OutputProfile dst{.profilePath = src, .fsPermission = FsPermission{.uid = -1, .gid = -1}}; |
| dst.profilePath.id = ""; |
| dst.profilePath.tmpPath = ""; |
| |
| bool result; |
| EXPECT_TRUE(artd_->copyAndRewriteProfile(src, &dst, dex_file_, &result).isOk()); |
| EXPECT_FALSE(result); |
| EXPECT_THAT(dst.profilePath.id, IsEmpty()); |
| EXPECT_THAT(dst.profilePath.tmpPath, IsEmpty()); |
| } |
| |
| TEST_F(ArtdTest, copyAndRewriteProfileFailed) { |
| const TmpProfilePath& src = profile_path_->get<ProfilePath::tmpProfilePath>(); |
| std::string src_file = OR_FATAL(BuildTmpProfilePath(src)); |
| CreateFile(src_file, "abc"); |
| OutputProfile dst{.profilePath = src, .fsPermission = FsPermission{.uid = -1, .gid = -1}}; |
| dst.profilePath.id = ""; |
| dst.profilePath.tmpPath = ""; |
| |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode(_, _, _)).WillOnce(Return(100)); |
| |
| bool result; |
| ndk::ScopedAStatus status = artd_->copyAndRewriteProfile(src, &dst, dex_file_, &result); |
| |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC); |
| EXPECT_THAT(status.getMessage(), HasSubstr("profman returned an unexpected code: 100")); |
| EXPECT_THAT(dst.profilePath.id, IsEmpty()); |
| EXPECT_THAT(dst.profilePath.tmpPath, IsEmpty()); |
| } |
| |
| TEST_F(ArtdTest, commitTmpProfile) { |
| const TmpProfilePath& tmp_profile_path = profile_path_->get<ProfilePath::tmpProfilePath>(); |
| std::string tmp_profile_file = OR_FATAL(BuildTmpProfilePath(tmp_profile_path)); |
| CreateFile(tmp_profile_file); |
| |
| EXPECT_TRUE(artd_->commitTmpProfile(tmp_profile_path).isOk()); |
| |
| EXPECT_FALSE(std::filesystem::exists(tmp_profile_file)); |
| EXPECT_TRUE(std::filesystem::exists(OR_FATAL(BuildFinalProfilePath(tmp_profile_path)))); |
| } |
| |
| TEST_F(ArtdTest, commitTmpProfileFailed) { |
| const TmpProfilePath& tmp_profile_path = profile_path_->get<ProfilePath::tmpProfilePath>(); |
| ndk::ScopedAStatus status = artd_->commitTmpProfile(tmp_profile_path); |
| |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC); |
| EXPECT_THAT( |
| status.getMessage(), |
| ContainsRegex(R"re(Failed to move .*primary\.prof\.12345\.tmp.* to .*primary\.prof)re")); |
| |
| EXPECT_FALSE(std::filesystem::exists(OR_FATAL(BuildFinalProfilePath(tmp_profile_path)))); |
| } |
| |
| TEST_F(ArtdTest, deleteProfile) { |
| std::string profile_file = OR_FATAL(BuildProfileOrDmPath(profile_path_.value())); |
| CreateFile(profile_file); |
| |
| EXPECT_TRUE(artd_->deleteProfile(profile_path_.value()).isOk()); |
| |
| EXPECT_FALSE(std::filesystem::exists(profile_file)); |
| } |
| |
| TEST_F(ArtdTest, deleteProfileDoesNotExist) { |
| auto scoped_set_logger = ScopedSetLogger(mock_logger_.AsStdFunction()); |
| EXPECT_CALL(mock_logger_, Call).Times(0); |
| |
| EXPECT_TRUE(artd_->deleteProfile(profile_path_.value()).isOk()); |
| } |
| |
| TEST_F(ArtdTest, deleteProfileFailed) { |
| auto scoped_set_logger = ScopedSetLogger(mock_logger_.AsStdFunction()); |
| EXPECT_CALL( |
| mock_logger_, |
| Call(_, _, _, _, _, ContainsRegex(R"re(Failed to remove .*primary\.prof\.12345\.tmp)re"))); |
| |
| std::string profile_file = OR_FATAL(BuildProfileOrDmPath(profile_path_.value())); |
| auto scoped_inaccessible = ScopedInaccessible(std::filesystem::path(profile_file).parent_path()); |
| auto scoped_unroot = ScopedUnroot(); |
| |
| EXPECT_TRUE(artd_->deleteProfile(profile_path_.value()).isOk()); |
| } |
| |
| class ArtdGetVisibilityTest : public ArtdTest { |
| protected: |
| template <typename PathType> |
| using Method = ndk::ScopedAStatus (Artd::*)(const PathType&, FileVisibility*); |
| |
| template <typename PathType> |
| void TestGetVisibilityOtherReadable(Method<PathType> method, |
| const PathType& input, |
| const std::string& path) { |
| CreateFile(path); |
| std::filesystem::permissions( |
| path, std::filesystem::perms::others_read, std::filesystem::perm_options::add); |
| |
| FileVisibility result; |
| ASSERT_TRUE(((*artd_).*method)(input, &result).isOk()); |
| EXPECT_EQ(result, FileVisibility::OTHER_READABLE); |
| } |
| |
| template <typename PathType> |
| void TestGetVisibilityNotOtherReadable(Method<PathType> method, |
| const PathType& input, |
| const std::string& path) { |
| CreateFile(path); |
| std::filesystem::permissions( |
| path, std::filesystem::perms::others_read, std::filesystem::perm_options::remove); |
| |
| FileVisibility result; |
| ASSERT_TRUE(((*artd_).*method)(input, &result).isOk()); |
| EXPECT_EQ(result, FileVisibility::NOT_OTHER_READABLE); |
| } |
| |
| template <typename PathType> |
| void TestGetVisibilityNotFound(Method<PathType> method, const PathType& input) { |
| FileVisibility result; |
| ASSERT_TRUE(((*artd_).*method)(input, &result).isOk()); |
| EXPECT_EQ(result, FileVisibility::NOT_FOUND); |
| } |
| |
| template <typename PathType> |
| void TestGetVisibilityPermissionDenied(Method<PathType> method, |
| const PathType& input, |
| const std::string& path) { |
| CreateFile(path); |
| |
| auto scoped_inaccessible = ScopedInaccessible(std::filesystem::path(path).parent_path()); |
| auto scoped_unroot = ScopedUnroot(); |
| |
| FileVisibility result; |
| ndk::ScopedAStatus status = ((*artd_).*method)(input, &result); |
| EXPECT_FALSE(status.isOk()); |
| EXPECT_EQ(status.getExceptionCode(), EX_SERVICE_SPECIFIC); |
| EXPECT_THAT(status.getMessage(), HasSubstr("Failed to get status of")); |
| } |
| }; |
| |
| TEST_F(ArtdGetVisibilityTest, getProfileVisibilityOtherReadable) { |
| TestGetVisibilityOtherReadable(&Artd::getProfileVisibility, |
| profile_path_.value(), |
| OR_FATAL(BuildProfileOrDmPath(profile_path_.value()))); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getProfileVisibilityNotOtherReadable) { |
| TestGetVisibilityNotOtherReadable(&Artd::getProfileVisibility, |
| profile_path_.value(), |
| OR_FATAL(BuildProfileOrDmPath(profile_path_.value()))); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getProfileVisibilityNotFound) { |
| TestGetVisibilityNotFound(&Artd::getProfileVisibility, profile_path_.value()); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getProfileVisibilityPermissionDenied) { |
| TestGetVisibilityPermissionDenied(&Artd::getProfileVisibility, |
| profile_path_.value(), |
| OR_FATAL(BuildProfileOrDmPath(profile_path_.value()))); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getArtifactsVisibilityOtherReadable) { |
| TestGetVisibilityOtherReadable( |
| &Artd::getArtifactsVisibility, artifacts_path_, OR_FATAL(BuildOatPath(artifacts_path_))); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getArtifactsVisibilityNotOtherReadable) { |
| TestGetVisibilityNotOtherReadable( |
| &Artd::getArtifactsVisibility, artifacts_path_, OR_FATAL(BuildOatPath(artifacts_path_))); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getArtifactsVisibilityNotFound) { |
| TestGetVisibilityNotFound(&Artd::getArtifactsVisibility, artifacts_path_); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getArtifactsVisibilityPermissionDenied) { |
| TestGetVisibilityPermissionDenied( |
| &Artd::getArtifactsVisibility, artifacts_path_, OR_FATAL(BuildOatPath(artifacts_path_))); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getDexFileVisibilityOtherReadable) { |
| TestGetVisibilityOtherReadable(&Artd::getDexFileVisibility, dex_file_, dex_file_); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getDexFileVisibilityNotOtherReadable) { |
| TestGetVisibilityNotOtherReadable(&Artd::getDexFileVisibility, dex_file_, dex_file_); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getDexFileVisibilityNotFound) { |
| TestGetVisibilityNotFound(&Artd::getDexFileVisibility, dex_file_); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getDexFileVisibilityPermissionDenied) { |
| TestGetVisibilityPermissionDenied(&Artd::getDexFileVisibility, dex_file_, dex_file_); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getDmFileVisibilityOtherReadable) { |
| TestGetVisibilityOtherReadable(&Artd::getDmFileVisibility, |
| dm_path_.value(), |
| OR_FATAL(BuildDexMetadataPath(dm_path_.value()))); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getDmFileVisibilityNotOtherReadable) { |
| TestGetVisibilityNotOtherReadable(&Artd::getDmFileVisibility, |
| dm_path_.value(), |
| OR_FATAL(BuildDexMetadataPath(dm_path_.value()))); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getDmFileVisibilityNotFound) { |
| TestGetVisibilityNotFound(&Artd::getDmFileVisibility, dm_path_.value()); |
| } |
| |
| TEST_F(ArtdGetVisibilityTest, getDmFileVisibilityPermissionDenied) { |
| TestGetVisibilityPermissionDenied(&Artd::getDmFileVisibility, |
| dm_path_.value(), |
| OR_FATAL(BuildDexMetadataPath(dm_path_.value()))); |
| } |
| |
| TEST_F(ArtdTest, mergeProfiles) { |
| const TmpProfilePath& reference_profile_path = profile_path_->get<ProfilePath::tmpProfilePath>(); |
| std::string reference_profile_file = OR_FATAL(BuildTmpProfilePath(reference_profile_path)); |
| CreateFile(reference_profile_file, "abc"); |
| |
| // Doesn't exist. |
| PrimaryCurProfilePath profile_0_path{ |
| .userId = 0, .packageName = "com.android.foo", .profileName = "primary"}; |
| std::string profile_0_file = OR_FATAL(BuildPrimaryCurProfilePath(profile_0_path)); |
| |
| PrimaryCurProfilePath profile_1_path{ |
| .userId = 1, .packageName = "com.android.foo", .profileName = "primary"}; |
| std::string profile_1_file = OR_FATAL(BuildPrimaryCurProfilePath(profile_1_path)); |
| CreateFile(profile_1_file, "def"); |
| |
| OutputProfile output_profile{.profilePath = reference_profile_path, |
| .fsPermission = FsPermission{.uid = -1, .gid = -1}}; |
| output_profile.profilePath.id = ""; |
| output_profile.profilePath.tmpPath = ""; |
| |
| std::string dex_file_1 = scratch_path_ + "/a/b.apk"; |
| std::string dex_file_2 = scratch_path_ + "/a/c.apk"; |
| CreateFile(dex_file_1); |
| CreateFile(dex_file_2); |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| AllOf(WhenSplitBy( |
| "--", |
| AllOf(Contains(art_root_ + "/bin/art_exec"), Contains("--drop-capabilities")), |
| AllOf(Contains(art_root_ + "/bin/profman"), |
| Not(Contains(Flag("--profile-file-fd=", FdOf(profile_0_file)))), |
| Contains(Flag("--profile-file-fd=", FdOf(profile_1_file))), |
| Contains(Flag("--reference-profile-file-fd=", FdHasContent("abc"))), |
| Contains(Flag("--apk-fd=", FdOf(dex_file_1))), |
| Contains(Flag("--apk-fd=", FdOf(dex_file_2))), |
| Not(Contains("--force-merge")), |
| Not(Contains("--boot-image-merge")))), |
| HasKeepFdsFor("--profile-file-fd=", "--reference-profile-file-fd=", "--apk-fd=")), |
| _, |
| _)) |
| .WillOnce(DoAll(WithArg<0>(ClearAndWriteToFdFlag("--reference-profile-file-fd=", "merged")), |
| Return(ProfmanResult::kCompile))); |
| |
| bool result; |
| EXPECT_TRUE(artd_ |
| ->mergeProfiles({profile_0_path, profile_1_path}, |
| reference_profile_path, |
| &output_profile, |
| {dex_file_1, dex_file_2}, |
| /*in_options=*/{}, |
| &result) |
| .isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_THAT(output_profile.profilePath.id, Not(IsEmpty())); |
| std::string real_path = OR_FATAL(BuildTmpProfilePath(output_profile.profilePath)); |
| EXPECT_EQ(output_profile.profilePath.tmpPath, real_path); |
| CheckContent(real_path, "merged"); |
| } |
| |
| TEST_F(ArtdTest, mergeProfilesEmptyReferenceProfile) { |
| PrimaryCurProfilePath profile_0_path{ |
| .userId = 0, .packageName = "com.android.foo", .profileName = "primary"}; |
| std::string profile_0_file = OR_FATAL(BuildPrimaryCurProfilePath(profile_0_path)); |
| CreateFile(profile_0_file, "def"); |
| |
| OutputProfile output_profile{.profilePath = profile_path_->get<ProfilePath::tmpProfilePath>(), |
| .fsPermission = FsPermission{.uid = -1, .gid = -1}}; |
| output_profile.profilePath.id = ""; |
| output_profile.profilePath.tmpPath = ""; |
| |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy("--", |
| AllOf(Contains(art_root_ + "/bin/art_exec"), Contains("--drop-capabilities")), |
| AllOf(Contains(art_root_ + "/bin/profman"), |
| Contains(Flag("--profile-file-fd=", FdOf(profile_0_file))), |
| Contains(Flag("--reference-profile-file-fd=", FdHasContent(""))), |
| Contains(Flag("--apk-fd=", FdOf(dex_file_))))), |
| _, |
| _)) |
| .WillOnce(DoAll(WithArg<0>(WriteToFdFlag("--reference-profile-file-fd=", "merged")), |
| Return(ProfmanResult::kCompile))); |
| |
| bool result; |
| EXPECT_TRUE(artd_ |
| ->mergeProfiles({profile_0_path}, |
| std::nullopt, |
| &output_profile, |
| {dex_file_}, |
| /*in_options=*/{}, |
| &result) |
| .isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_THAT(output_profile.profilePath.id, Not(IsEmpty())); |
| EXPECT_THAT(output_profile.profilePath.tmpPath, Not(IsEmpty())); |
| } |
| |
| TEST_F(ArtdTest, mergeProfilesProfilesDontExist) { |
| const TmpProfilePath& reference_profile_path = profile_path_->get<ProfilePath::tmpProfilePath>(); |
| std::string reference_profile_file = OR_FATAL(BuildTmpProfilePath(reference_profile_path)); |
| CreateFile(reference_profile_file, "abc"); |
| |
| // Doesn't exist. |
| PrimaryCurProfilePath profile_0_path{ |
| .userId = 0, .packageName = "com.android.foo", .profileName = "primary"}; |
| std::string profile_0_file = OR_FATAL(BuildPrimaryCurProfilePath(profile_0_path)); |
| |
| // Doesn't exist. |
| PrimaryCurProfilePath profile_1_path{ |
| .userId = 1, .packageName = "com.android.foo", .profileName = "primary"}; |
| std::string profile_1_file = OR_FATAL(BuildPrimaryCurProfilePath(profile_1_path)); |
| |
| OutputProfile output_profile{.profilePath = reference_profile_path, |
| .fsPermission = FsPermission{.uid = -1, .gid = -1}}; |
| output_profile.profilePath.id = ""; |
| output_profile.profilePath.tmpPath = ""; |
| |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL(*mock_exec_utils_, DoExecAndReturnCode).Times(0); |
| |
| bool result; |
| EXPECT_TRUE(artd_ |
| ->mergeProfiles({profile_0_path}, |
| std::nullopt, |
| &output_profile, |
| {dex_file_}, |
| /*in_options=*/{}, |
| &result) |
| .isOk()); |
| EXPECT_FALSE(result); |
| EXPECT_THAT(output_profile.profilePath.id, IsEmpty()); |
| EXPECT_THAT(output_profile.profilePath.tmpPath, IsEmpty()); |
| } |
| |
| TEST_F(ArtdTest, mergeProfilesWithOptionsForceMerge) { |
| PrimaryCurProfilePath profile_0_path{ |
| .userId = 0, .packageName = "com.android.foo", .profileName = "primary"}; |
| std::string profile_0_file = OR_FATAL(BuildPrimaryCurProfilePath(profile_0_path)); |
| CreateFile(profile_0_file, "def"); |
| |
| OutputProfile output_profile{.profilePath = profile_path_->get<ProfilePath::tmpProfilePath>(), |
| .fsPermission = FsPermission{.uid = -1, .gid = -1}}; |
| output_profile.profilePath.id = ""; |
| output_profile.profilePath.tmpPath = ""; |
| |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL( |
| *mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy("--", _, AllOf(Contains("--force-merge"), Contains("--boot-image-merge"))), |
| _, |
| _)) |
| .WillOnce(Return(ProfmanResult::kSuccess)); |
| |
| bool result; |
| EXPECT_TRUE(artd_ |
| ->mergeProfiles({profile_0_path}, |
| std::nullopt, |
| &output_profile, |
| {dex_file_}, |
| {.forceMerge = true, .forBootImage = true}, |
| &result) |
| .isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_THAT(output_profile.profilePath.id, Not(IsEmpty())); |
| EXPECT_THAT(output_profile.profilePath.tmpPath, Not(IsEmpty())); |
| } |
| |
| TEST_F(ArtdTest, mergeProfilesWithOptionsDumpOnly) { |
| PrimaryCurProfilePath profile_0_path{ |
| .userId = 0, .packageName = "com.android.foo", .profileName = "primary"}; |
| std::string profile_0_file = OR_FATAL(BuildPrimaryCurProfilePath(profile_0_path)); |
| CreateFile(profile_0_file, "def"); |
| |
| OutputProfile output_profile{.profilePath = profile_path_->get<ProfilePath::tmpProfilePath>(), |
| .fsPermission = FsPermission{.uid = -1, .gid = -1}}; |
| output_profile.profilePath.id = ""; |
| output_profile.profilePath.tmpPath = ""; |
| |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL(*mock_exec_utils_, |
| DoExecAndReturnCode( |
| AllOf(WhenSplitBy("--", |
| _, |
| AllOf(Contains("--dump-only"), |
| Not(Contains(Flag("--reference-profile-file-fd=", _))))), |
| HasKeepFdsFor("--profile-file-fd=", "--apk-fd=", "--dump-output-to-fd=")), |
| _, |
| _)) |
| .WillOnce(DoAll(WithArg<0>(WriteToFdFlag("--dump-output-to-fd=", "dump")), |
| Return(ProfmanResult::kSuccess))); |
| |
| bool result; |
| EXPECT_TRUE(artd_ |
| ->mergeProfiles({profile_0_path}, |
| std::nullopt, |
| &output_profile, |
| {dex_file_}, |
| {.dumpOnly = true}, |
| &result) |
| .isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_THAT(output_profile.profilePath.id, Not(IsEmpty())); |
| CheckContent(output_profile.profilePath.tmpPath, "dump"); |
| } |
| |
| TEST_F(ArtdTest, mergeProfilesWithOptionsDumpClassesAndMethods) { |
| PrimaryCurProfilePath profile_0_path{ |
| .userId = 0, .packageName = "com.android.foo", .profileName = "primary"}; |
| std::string profile_0_file = OR_FATAL(BuildPrimaryCurProfilePath(profile_0_path)); |
| CreateFile(profile_0_file, "def"); |
| |
| OutputProfile output_profile{.profilePath = profile_path_->get<ProfilePath::tmpProfilePath>(), |
| .fsPermission = FsPermission{.uid = -1, .gid = -1}}; |
| output_profile.profilePath.id = ""; |
| output_profile.profilePath.tmpPath = ""; |
| |
| CreateFile(dex_file_); |
| |
| EXPECT_CALL(*mock_exec_utils_, |
| DoExecAndReturnCode( |
| WhenSplitBy("--", |
| _, |
| AllOf(Contains("--dump-classes-and-methods"), |
| Not(Contains(Flag("--reference-profile-file-fd=", _))))), |
| _, |
| _)) |
| .WillOnce(DoAll(WithArg<0>(WriteToFdFlag("--dump-output-to-fd=", "dump")), |
| Return(ProfmanResult::kSuccess))); |
| |
| bool result; |
| EXPECT_TRUE(artd_ |
| ->mergeProfiles({profile_0_path}, |
| std::nullopt, |
| &output_profile, |
| {dex_file_}, |
| {.dumpClassesAndMethods = true}, |
| &result) |
| .isOk()); |
| EXPECT_TRUE(result); |
| EXPECT_THAT(output_profile.profilePath.id, Not(IsEmpty())); |
| CheckContent(output_profile.profilePath.tmpPath, "dump"); |
| } |
| |
| TEST_F(ArtdTest, cleanup) { |
| std::vector<std::string> gc_removed_files; |
| std::vector<std::string> gc_kept_files; |
| |
| auto CreateGcRemovedFile = [&](const std::string& path) { |
| CreateFile(path); |
| gc_removed_files.push_back(path); |
| }; |
| |
| auto CreateGcKeptFile = [&](const std::string& path) { |
| CreateFile(path); |
| gc_kept_files.push_back(path); |
| }; |
| |
| // Unmanaged files. |
| CreateGcKeptFile(android_data_ + "/user_de/0/com.android.foo/1.odex"); |
| CreateGcKeptFile(android_data_ + "/user_de/0/com.android.foo/oat/1.odex"); |
| CreateGcKeptFile(android_data_ + "/user_de/0/com.android.foo/oat/1.txt"); |
| CreateGcKeptFile(android_data_ + "/user_de/0/com.android.foo/oat/arm64/1.txt"); |
| CreateGcKeptFile(android_data_ + "/user_de/0/com.android.foo/oat/arm64/1.tmp"); |
| |
| // Files to keep. |
| CreateGcKeptFile(android_data_ + "/misc/profiles/cur/1/com.android.foo/primary.prof"); |
| CreateGcKeptFile(android_data_ + "/misc/profiles/cur/3/com.android.foo/primary.prof"); |
| CreateGcKeptFile(android_data_ + "/dalvik-cache/arm64/system@app@Foo@Foo.apk@classes.dex"); |
| CreateGcKeptFile(android_data_ + "/dalvik-cache/arm64/system@app@Foo@Foo.apk@classes.vdex"); |
| CreateGcKeptFile(android_data_ + "/dalvik-cache/arm64/system@app@Foo@Foo.apk@classes.art"); |
| CreateGcKeptFile(android_data_ + "/user_de/0/com.android.foo/aaa/oat/arm64/1.vdex"); |
| CreateGcKeptFile( |
| android_expand_ + |
| "/123456-7890/app/~~nkfeankfna==/com.android.bar-jfoeaofiew==/oat/arm64/base.odex"); |
| CreateGcKeptFile( |
| android_expand_ + |
| "/123456-7890/app/~~nkfeankfna==/com.android.bar-jfoeaofiew==/oat/arm64/base.vdex"); |
| CreateGcKeptFile( |
| android_expand_ + |
| "/123456-7890/app/~~nkfeankfna==/com.android.bar-jfoeaofiew==/oat/arm64/base.art"); |
| CreateGcKeptFile(android_data_ + "/user_de/0/com.android.foo/aaa/oat/arm64/2.odex"); |
| CreateGcKeptFile(android_data_ + "/user_de/0/com.android.foo/aaa/oat/arm64/2.vdex"); |
| CreateGcKeptFile(android_data_ + "/user_de/0/com.android.foo/aaa/oat/arm64/2.art"); |
| |
| // Files to remove. |
| CreateGcRemovedFile(android_data_ + "/misc/profiles/ref/com.android.foo/primary.prof"); |
| CreateGcRemovedFile(android_data_ + "/misc/profiles/cur/2/com.android.foo/primary.prof"); |
| CreateGcRemovedFile(android_data_ + "/misc/profiles/cur/3/com.android.bar/primary.prof"); |
| CreateGcRemovedFile(android_data_ + "/dalvik-cache/arm64/extra.odex"); |
| CreateGcRemovedFile(android_data_ + "/dalvik-cache/arm64/system@app@Bar@Bar.apk@classes.dex"); |
| CreateGcRemovedFile(android_data_ + "/dalvik-cache/arm64/system@app@Bar@Bar.apk@classes.vdex"); |
| CreateGcRemovedFile(android_data_ + "/dalvik-cache/arm64/system@app@Bar@Bar.apk@classes.art"); |
| CreateGcRemovedFile( |
| android_expand_ + |
| "/123456-7890/app/~~daewfweaf==/com.android.foo-fjuwidhia==/oat/arm64/base.odex"); |
| CreateGcRemovedFile( |
| android_expand_ + |
| "/123456-7890/app/~~daewfweaf==/com.android.foo-fjuwidhia==/oat/arm64/base.vdex"); |
| CreateGcRemovedFile( |
| android_expand_ + |
| "/123456-7890/app/~~daewfweaf==/com.android.foo-fjuwidhia==/oat/arm64/base.art"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/oat/1.prof"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/oat/1.prof.123456.tmp"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/oat/arm64/1.odex"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/oat/arm64/1.vdex"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/oat/arm64/1.art"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/oat/arm64/1.odex.123456.tmp"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/oat/arm64/2.odex.123456.tmp"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/aaa/oat/arm64/1.odex"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/aaa/oat/arm64/1.art"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/aaa/oat/arm64/1.vdex.123456.tmp"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/aaa/bbb/oat/arm64/1.odex"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/aaa/bbb/oat/arm64/1.vdex"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.foo/aaa/bbb/oat/arm64/1.art"); |
| CreateGcRemovedFile(android_data_ + |
| "/user_de/0/com.android.foo/aaa/bbb/oat/arm64/1.art.123456.tmp"); |
| CreateGcRemovedFile(android_data_ + "/user_de/0/com.android.bar/aaa/oat/arm64/1.vdex"); |
| |
| int64_t aidl_return; |
| ASSERT_TRUE( |
| artd_ |
| ->cleanup( |
| { |
| PrimaryCurProfilePath{ |
| .userId = 1, .packageName = "com.android.foo", .profileName = "primary"}, |
| PrimaryCurProfilePath{ |
| .userId = 3, .packageName = "com.android.foo", .profileName = "primary"}, |
| }, |
| { |
| ArtifactsPath{.dexPath = "/system/app/Foo/Foo.apk", |
| .isa = "arm64", |
| .isInDalvikCache = true}, |
| ArtifactsPath{ |
| .dexPath = |
| android_expand_ + |
| "/123456-7890/app/~~nkfeankfna==/com.android.bar-jfoeaofiew==/base.apk", |
| .isa = "arm64", |
| .isInDalvikCache = false}, |
| ArtifactsPath{.dexPath = android_data_ + "/user_de/0/com.android.foo/aaa/2.apk", |
| .isa = "arm64", |
| .isInDalvikCache = false}, |
| }, |
| { |
| VdexPath{ArtifactsPath{ |
| .dexPath = android_data_ + "/user_de/0/com.android.foo/aaa/1.apk", |
| .isa = "arm64", |
| .isInDalvikCache = false}}, |
| }, |
| &aidl_return) |
| .isOk()); |
| |
| for (const std::string& path : gc_removed_files) { |
| EXPECT_FALSE(std::filesystem::exists(path)) << "'{}' should be removed"_format(path); |
| } |
| |
| for (const std::string& path : gc_kept_files) { |
| EXPECT_TRUE(std::filesystem::exists(path)) << "'{}' should be kept"_format(path); |
| } |
| } |
| |
| } // namespace |
| } // namespace artd |
| } // namespace art |