| /* |
| * Copyright (C) 2012 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 "common_art_test.h" |
| |
| #include <dirent.h> |
| #include <dlfcn.h> |
| #include <fcntl.h> |
| #include <stdlib.h> |
| #include <cstdio> |
| #include "nativehelper/scoped_local_ref.h" |
| |
| #include "android-base/stringprintf.h" |
| #include "android-base/unique_fd.h" |
| #include <unicode/uvernum.h> |
| |
| #include "art_field-inl.h" |
| #include "base/file_utils.h" |
| #include "base/logging.h" |
| #include "base/macros.h" |
| #include "base/mem_map.h" |
| #include "base/mutex.h" |
| #include "base/os.h" |
| #include "base/runtime_debug.h" |
| #include "base/stl_util.h" |
| #include "base/unix_file/fd_file.h" |
| #include "dex/art_dex_file_loader.h" |
| #include "dex/dex_file-inl.h" |
| #include "dex/dex_file_loader.h" |
| #include "dex/primitive.h" |
| #include "gtest/gtest.h" |
| |
| namespace art { |
| |
| using android::base::StringPrintf; |
| |
| ScratchFile::ScratchFile() { |
| // ANDROID_DATA needs to be set |
| CHECK_NE(static_cast<char*>(nullptr), getenv("ANDROID_DATA")) << |
| "Are you subclassing RuntimeTest?"; |
| filename_ = getenv("ANDROID_DATA"); |
| filename_ += "/TmpFile-XXXXXX"; |
| int fd = mkstemp(&filename_[0]); |
| CHECK_NE(-1, fd) << strerror(errno) << " for " << filename_; |
| file_.reset(new File(fd, GetFilename(), true)); |
| } |
| |
| ScratchFile::ScratchFile(const ScratchFile& other, const char* suffix) |
| : ScratchFile(other.GetFilename() + suffix) {} |
| |
| ScratchFile::ScratchFile(const std::string& filename) : filename_(filename) { |
| int fd = open(filename_.c_str(), O_RDWR | O_CREAT, 0666); |
| CHECK_NE(-1, fd); |
| file_.reset(new File(fd, GetFilename(), true)); |
| } |
| |
| ScratchFile::ScratchFile(File* file) { |
| CHECK(file != nullptr); |
| filename_ = file->GetPath(); |
| file_.reset(file); |
| } |
| |
| ScratchFile::ScratchFile(ScratchFile&& other) { |
| *this = std::move(other); |
| } |
| |
| ScratchFile& ScratchFile::operator=(ScratchFile&& other) { |
| if (GetFile() != other.GetFile()) { |
| std::swap(filename_, other.filename_); |
| std::swap(file_, other.file_); |
| } |
| return *this; |
| } |
| |
| ScratchFile::~ScratchFile() { |
| Unlink(); |
| } |
| |
| int ScratchFile::GetFd() const { |
| return file_->Fd(); |
| } |
| |
| void ScratchFile::Close() { |
| if (file_.get() != nullptr) { |
| if (file_->FlushCloseOrErase() != 0) { |
| PLOG(WARNING) << "Error closing scratch file."; |
| } |
| } |
| } |
| |
| void ScratchFile::Unlink() { |
| if (!OS::FileExists(filename_.c_str())) { |
| return; |
| } |
| Close(); |
| int unlink_result = unlink(filename_.c_str()); |
| CHECK_EQ(0, unlink_result); |
| } |
| |
| void CommonArtTestImpl::SetUpAndroidRoot() { |
| if (IsHost()) { |
| // $ANDROID_ROOT is set on the device, but not necessarily on the host. |
| // But it needs to be set so that icu4c can find its locale data. |
| const char* android_root_from_env = getenv("ANDROID_ROOT"); |
| if (android_root_from_env == nullptr) { |
| // Use ANDROID_HOST_OUT for ANDROID_ROOT if it is set. |
| const char* android_host_out = getenv("ANDROID_HOST_OUT"); |
| if (android_host_out != nullptr) { |
| setenv("ANDROID_ROOT", android_host_out, 1); |
| } else { |
| // Build it from ANDROID_BUILD_TOP or cwd |
| std::string root; |
| const char* android_build_top = getenv("ANDROID_BUILD_TOP"); |
| if (android_build_top != nullptr) { |
| root += android_build_top; |
| } else { |
| // Not set by build server, so default to current directory |
| char* cwd = getcwd(nullptr, 0); |
| setenv("ANDROID_BUILD_TOP", cwd, 1); |
| root += cwd; |
| free(cwd); |
| } |
| #if defined(__linux__) |
| root += "/out/host/linux-x86"; |
| #elif defined(__APPLE__) |
| root += "/out/host/darwin-x86"; |
| #else |
| #error unsupported OS |
| #endif |
| setenv("ANDROID_ROOT", root.c_str(), 1); |
| } |
| } |
| setenv("LD_LIBRARY_PATH", ":", 0); // Required by java.lang.System.<clinit>. |
| |
| // Not set by build server, so default |
| if (getenv("ANDROID_HOST_OUT") == nullptr) { |
| setenv("ANDROID_HOST_OUT", getenv("ANDROID_ROOT"), 1); |
| } |
| } |
| } |
| |
| void CommonArtTestImpl::SetUpAndroidData(std::string& android_data) { |
| // On target, Cannot use /mnt/sdcard because it is mounted noexec, so use subdir of dalvik-cache |
| if (IsHost()) { |
| const char* tmpdir = getenv("TMPDIR"); |
| if (tmpdir != nullptr && tmpdir[0] != 0) { |
| android_data = tmpdir; |
| } else { |
| android_data = "/tmp"; |
| } |
| } else { |
| android_data = "/data/dalvik-cache"; |
| } |
| android_data += "/art-data-XXXXXX"; |
| if (mkdtemp(&android_data[0]) == nullptr) { |
| PLOG(FATAL) << "mkdtemp(\"" << &android_data[0] << "\") failed"; |
| } |
| setenv("ANDROID_DATA", android_data.c_str(), 1); |
| } |
| |
| void CommonArtTestImpl::SetUp() { |
| SetUpAndroidRoot(); |
| SetUpAndroidData(android_data_); |
| dalvik_cache_.append(android_data_.c_str()); |
| dalvik_cache_.append("/dalvik-cache"); |
| int mkdir_result = mkdir(dalvik_cache_.c_str(), 0700); |
| ASSERT_EQ(mkdir_result, 0); |
| } |
| |
| void CommonArtTestImpl::TearDownAndroidData(const std::string& android_data, bool fail_on_error) { |
| if (fail_on_error) { |
| ASSERT_EQ(rmdir(android_data.c_str()), 0); |
| } else { |
| rmdir(android_data.c_str()); |
| } |
| } |
| |
| // Helper - find directory with the following format: |
| // ${ANDROID_BUILD_TOP}/${subdir1}/${subdir2}-${version}/${subdir3}/bin/ |
| std::string CommonArtTestImpl::GetAndroidToolsDir(const std::string& subdir1, |
| const std::string& subdir2, |
| const std::string& subdir3) { |
| std::string root; |
| const char* android_build_top = getenv("ANDROID_BUILD_TOP"); |
| if (android_build_top != nullptr) { |
| root = android_build_top; |
| } else { |
| // Not set by build server, so default to current directory |
| char* cwd = getcwd(nullptr, 0); |
| setenv("ANDROID_BUILD_TOP", cwd, 1); |
| root = cwd; |
| free(cwd); |
| } |
| |
| std::string toolsdir = root + "/" + subdir1; |
| std::string founddir; |
| DIR* dir; |
| if ((dir = opendir(toolsdir.c_str())) != nullptr) { |
| float maxversion = 0; |
| struct dirent* entry; |
| while ((entry = readdir(dir)) != nullptr) { |
| std::string format = subdir2 + "-%f"; |
| float version; |
| if (std::sscanf(entry->d_name, format.c_str(), &version) == 1) { |
| if (version > maxversion) { |
| maxversion = version; |
| founddir = toolsdir + "/" + entry->d_name + "/" + subdir3 + "/bin/"; |
| } |
| } |
| } |
| closedir(dir); |
| } |
| |
| if (founddir.empty()) { |
| ADD_FAILURE() << "Cannot find Android tools directory."; |
| } |
| return founddir; |
| } |
| |
| std::string CommonArtTestImpl::GetAndroidHostToolsDir() { |
| return GetAndroidToolsDir("prebuilts/gcc/linux-x86/host", |
| "x86_64-linux-glibc2.15", |
| "x86_64-linux"); |
| } |
| |
| std::string CommonArtTestImpl::GetCoreArtLocation() { |
| return GetCoreFileLocation("art"); |
| } |
| |
| std::string CommonArtTestImpl::GetCoreOatLocation() { |
| return GetCoreFileLocation("oat"); |
| } |
| |
| std::unique_ptr<const DexFile> CommonArtTestImpl::LoadExpectSingleDexFile(const char* location) { |
| std::vector<std::unique_ptr<const DexFile>> dex_files; |
| std::string error_msg; |
| MemMap::Init(); |
| static constexpr bool kVerifyChecksum = true; |
| const ArtDexFileLoader dex_file_loader; |
| if (!dex_file_loader.Open( |
| location, location, /* verify */ true, kVerifyChecksum, &error_msg, &dex_files)) { |
| LOG(FATAL) << "Could not open .dex file '" << location << "': " << error_msg << "\n"; |
| UNREACHABLE(); |
| } else { |
| CHECK_EQ(1U, dex_files.size()) << "Expected only one dex file in " << location; |
| return std::move(dex_files[0]); |
| } |
| } |
| |
| void CommonArtTestImpl::ClearDirectory(const char* dirpath, bool recursive) { |
| ASSERT_TRUE(dirpath != nullptr); |
| DIR* dir = opendir(dirpath); |
| ASSERT_TRUE(dir != nullptr); |
| dirent* e; |
| struct stat s; |
| while ((e = readdir(dir)) != nullptr) { |
| if ((strcmp(e->d_name, ".") == 0) || (strcmp(e->d_name, "..") == 0)) { |
| continue; |
| } |
| std::string filename(dirpath); |
| filename.push_back('/'); |
| filename.append(e->d_name); |
| int stat_result = lstat(filename.c_str(), &s); |
| ASSERT_EQ(0, stat_result) << "unable to stat " << filename; |
| if (S_ISDIR(s.st_mode)) { |
| if (recursive) { |
| ClearDirectory(filename.c_str()); |
| int rmdir_result = rmdir(filename.c_str()); |
| ASSERT_EQ(0, rmdir_result) << filename; |
| } |
| } else { |
| int unlink_result = unlink(filename.c_str()); |
| ASSERT_EQ(0, unlink_result) << filename; |
| } |
| } |
| closedir(dir); |
| } |
| |
| void CommonArtTestImpl::TearDown() { |
| const char* android_data = getenv("ANDROID_DATA"); |
| ASSERT_TRUE(android_data != nullptr); |
| ClearDirectory(dalvik_cache_.c_str()); |
| int rmdir_cache_result = rmdir(dalvik_cache_.c_str()); |
| ASSERT_EQ(0, rmdir_cache_result); |
| TearDownAndroidData(android_data_, true); |
| dalvik_cache_.clear(); |
| } |
| |
| static std::string GetDexFileName(const std::string& jar_prefix, bool host) { |
| std::string path; |
| if (host) { |
| const char* host_dir = getenv("ANDROID_HOST_OUT"); |
| CHECK(host_dir != nullptr); |
| path = host_dir; |
| } else { |
| path = GetAndroidRoot(); |
| } |
| |
| std::string suffix = host |
| ? "-hostdex" // The host version. |
| : "-testdex"; // The unstripped target version. |
| |
| return StringPrintf("%s/framework/%s%s.jar", path.c_str(), jar_prefix.c_str(), suffix.c_str()); |
| } |
| |
| std::vector<std::string> CommonArtTestImpl::GetLibCoreDexFileNames() { |
| return std::vector<std::string>({GetDexFileName("core-oj", IsHost()), |
| GetDexFileName("core-libart", IsHost()), |
| GetDexFileName("core-simple", IsHost())}); |
| } |
| |
| std::string CommonArtTestImpl::GetTestAndroidRoot() { |
| if (IsHost()) { |
| const char* host_dir = getenv("ANDROID_HOST_OUT"); |
| CHECK(host_dir != nullptr); |
| return host_dir; |
| } |
| return GetAndroidRoot(); |
| } |
| |
| // Check that for target builds we have ART_TARGET_NATIVETEST_DIR set. |
| #ifdef ART_TARGET |
| #ifndef ART_TARGET_NATIVETEST_DIR |
| #error "ART_TARGET_NATIVETEST_DIR not set." |
| #endif |
| // Wrap it as a string literal. |
| #define ART_TARGET_NATIVETEST_DIR_STRING STRINGIFY(ART_TARGET_NATIVETEST_DIR) "/" |
| #else |
| #define ART_TARGET_NATIVETEST_DIR_STRING "" |
| #endif |
| |
| std::string CommonArtTestImpl::GetTestDexFileName(const char* name) const { |
| CHECK(name != nullptr); |
| std::string filename; |
| if (IsHost()) { |
| filename += getenv("ANDROID_HOST_OUT"); |
| filename += "/framework/"; |
| } else { |
| filename += ART_TARGET_NATIVETEST_DIR_STRING; |
| } |
| filename += "art-gtest-"; |
| filename += name; |
| filename += ".jar"; |
| return filename; |
| } |
| |
| std::vector<std::unique_ptr<const DexFile>> CommonArtTestImpl::OpenDexFiles(const char* filename) { |
| static constexpr bool kVerify = true; |
| static constexpr bool kVerifyChecksum = true; |
| std::string error_msg; |
| const ArtDexFileLoader dex_file_loader; |
| std::vector<std::unique_ptr<const DexFile>> dex_files; |
| bool success = dex_file_loader.Open(filename, |
| filename, |
| kVerify, |
| kVerifyChecksum, |
| &error_msg, |
| &dex_files); |
| CHECK(success) << "Failed to open '" << filename << "': " << error_msg; |
| for (auto& dex_file : dex_files) { |
| CHECK_EQ(PROT_READ, dex_file->GetPermissions()); |
| CHECK(dex_file->IsReadOnly()); |
| } |
| return dex_files; |
| } |
| |
| std::vector<std::unique_ptr<const DexFile>> CommonArtTestImpl::OpenTestDexFiles( |
| const char* name) { |
| return OpenDexFiles(GetTestDexFileName(name).c_str()); |
| } |
| |
| std::unique_ptr<const DexFile> CommonArtTestImpl::OpenTestDexFile(const char* name) { |
| std::vector<std::unique_ptr<const DexFile>> vector = OpenTestDexFiles(name); |
| EXPECT_EQ(1U, vector.size()); |
| return std::move(vector[0]); |
| } |
| |
| std::string CommonArtTestImpl::GetCoreFileLocation(const char* suffix) { |
| CHECK(suffix != nullptr); |
| |
| std::string location; |
| if (IsHost()) { |
| const char* host_dir = getenv("ANDROID_HOST_OUT"); |
| CHECK(host_dir != nullptr); |
| location = StringPrintf("%s/framework/core.%s", host_dir, suffix); |
| } else { |
| location = StringPrintf("/data/art-test/core.%s", suffix); |
| } |
| |
| return location; |
| } |
| |
| std::string CommonArtTestImpl::CreateClassPath( |
| const std::vector<std::unique_ptr<const DexFile>>& dex_files) { |
| CHECK(!dex_files.empty()); |
| std::string classpath = dex_files[0]->GetLocation(); |
| for (size_t i = 1; i < dex_files.size(); i++) { |
| classpath += ":" + dex_files[i]->GetLocation(); |
| } |
| return classpath; |
| } |
| |
| std::string CommonArtTestImpl::CreateClassPathWithChecksums( |
| const std::vector<std::unique_ptr<const DexFile>>& dex_files) { |
| CHECK(!dex_files.empty()); |
| std::string classpath = dex_files[0]->GetLocation() + "*" + |
| std::to_string(dex_files[0]->GetLocationChecksum()); |
| for (size_t i = 1; i < dex_files.size(); i++) { |
| classpath += ":" + dex_files[i]->GetLocation() + "*" + |
| std::to_string(dex_files[i]->GetLocationChecksum()); |
| } |
| return classpath; |
| } |
| |
| CommonArtTestImpl::ForkAndExecResult CommonArtTestImpl::ForkAndExec( |
| const std::vector<std::string>& argv, |
| const PostForkFn& post_fork, |
| const OutputHandlerFn& handler) { |
| ForkAndExecResult result; |
| result.status_code = 0; |
| result.stage = ForkAndExecResult::kLink; |
| |
| std::vector<const char*> c_args; |
| for (const std::string& str : argv) { |
| c_args.push_back(str.c_str()); |
| } |
| c_args.push_back(nullptr); |
| |
| android::base::unique_fd link[2]; |
| { |
| int link_fd[2]; |
| |
| if (pipe(link_fd) == -1) { |
| return result; |
| } |
| link[0].reset(link_fd[0]); |
| link[1].reset(link_fd[1]); |
| } |
| |
| result.stage = ForkAndExecResult::kFork; |
| |
| pid_t pid = fork(); |
| if (pid == -1) { |
| return result; |
| } |
| |
| if (pid == 0) { |
| if (!post_fork()) { |
| LOG(ERROR) << "Failed post-fork function"; |
| exit(1); |
| UNREACHABLE(); |
| } |
| |
| // Redirect stdout and stderr. |
| dup2(link[1].get(), STDOUT_FILENO); |
| dup2(link[1].get(), STDERR_FILENO); |
| |
| link[0].reset(); |
| link[1].reset(); |
| |
| execv(c_args[0], const_cast<char* const*>(c_args.data())); |
| exit(1); |
| UNREACHABLE(); |
| } |
| |
| result.stage = ForkAndExecResult::kWaitpid; |
| link[1].reset(); |
| |
| char buffer[128] = { 0 }; |
| ssize_t bytes_read = 0; |
| while (TEMP_FAILURE_RETRY(bytes_read = read(link[0].get(), buffer, 128)) > 0) { |
| handler(buffer, bytes_read); |
| } |
| handler(buffer, 0u); // End with a virtual write of zero length to simplify clients. |
| |
| link[0].reset(); |
| |
| if (waitpid(pid, &result.status_code, 0) == -1) { |
| return result; |
| } |
| |
| result.stage = ForkAndExecResult::kFinished; |
| return result; |
| } |
| |
| CommonArtTestImpl::ForkAndExecResult CommonArtTestImpl::ForkAndExec( |
| const std::vector<std::string>& argv, const PostForkFn& post_fork, std::string* output) { |
| auto string_collect_fn = [output](char* buf, size_t len) { |
| *output += std::string(buf, len); |
| }; |
| return ForkAndExec(argv, post_fork, string_collect_fn); |
| } |
| |
| } // namespace art |