1 /*
2  * Copyright (C) 2012 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "common_runtime_test.h"
18 
19 #include <dirent.h>
20 #include <dlfcn.h>
21 #include <fcntl.h>
22 #include <ScopedLocalRef.h>
23 
24 #include "../../external/icu/icu4c/source/common/unicode/uvernum.h"
25 #include "base/macros.h"
26 #include "base/logging.h"
27 #include "base/stl_util.h"
28 #include "base/stringprintf.h"
29 #include "base/unix_file/fd_file.h"
30 #include "class_linker.h"
31 #include "compiler_callbacks.h"
32 #include "dex_file.h"
33 #include "gc_root-inl.h"
34 #include "gc/heap.h"
35 #include "gtest/gtest.h"
36 #include "jni_internal.h"
37 #include "mirror/class_loader.h"
38 #include "noop_compiler_callbacks.h"
39 #include "os.h"
40 #include "runtime-inl.h"
41 #include "scoped_thread_state_change.h"
42 #include "thread.h"
43 #include "well_known_classes.h"
44 
main(int argc,char ** argv)45 int main(int argc, char **argv) {
46   art::InitLogging(argv);
47   LOG(INFO) << "Running main() from common_runtime_test.cc...";
48   testing::InitGoogleTest(&argc, argv);
49   return RUN_ALL_TESTS();
50 }
51 
52 namespace art {
53 
ScratchFile()54 ScratchFile::ScratchFile() {
55   // ANDROID_DATA needs to be set
56   CHECK_NE(static_cast<char*>(nullptr), getenv("ANDROID_DATA")) <<
57       "Are you subclassing RuntimeTest?";
58   filename_ = getenv("ANDROID_DATA");
59   filename_ += "/TmpFile-XXXXXX";
60   int fd = mkstemp(&filename_[0]);
61   CHECK_NE(-1, fd);
62   file_.reset(new File(fd, GetFilename(), true));
63 }
64 
ScratchFile(const ScratchFile & other,const char * suffix)65 ScratchFile::ScratchFile(const ScratchFile& other, const char* suffix) {
66   filename_ = other.GetFilename();
67   filename_ += suffix;
68   int fd = open(filename_.c_str(), O_RDWR | O_CREAT, 0666);
69   CHECK_NE(-1, fd);
70   file_.reset(new File(fd, GetFilename(), true));
71 }
72 
ScratchFile(File * file)73 ScratchFile::ScratchFile(File* file) {
74   CHECK(file != NULL);
75   filename_ = file->GetPath();
76   file_.reset(file);
77 }
78 
~ScratchFile()79 ScratchFile::~ScratchFile() {
80   Unlink();
81 }
82 
GetFd() const83 int ScratchFile::GetFd() const {
84   return file_->Fd();
85 }
86 
Close()87 void ScratchFile::Close() {
88   if (file_.get() != nullptr) {
89     if (file_->FlushCloseOrErase() != 0) {
90       PLOG(WARNING) << "Error closing scratch file.";
91     }
92   }
93 }
94 
Unlink()95 void ScratchFile::Unlink() {
96   if (!OS::FileExists(filename_.c_str())) {
97     return;
98   }
99   Close();
100   int unlink_result = unlink(filename_.c_str());
101   CHECK_EQ(0, unlink_result);
102 }
103 
CommonRuntimeTest()104 CommonRuntimeTest::CommonRuntimeTest() {}
~CommonRuntimeTest()105 CommonRuntimeTest::~CommonRuntimeTest() {}
106 
SetUpAndroidRoot()107 void CommonRuntimeTest::SetUpAndroidRoot() {
108   if (IsHost()) {
109     // $ANDROID_ROOT is set on the device, but not necessarily on the host.
110     // But it needs to be set so that icu4c can find its locale data.
111     const char* android_root_from_env = getenv("ANDROID_ROOT");
112     if (android_root_from_env == nullptr) {
113       // Use ANDROID_HOST_OUT for ANDROID_ROOT if it is set.
114       const char* android_host_out = getenv("ANDROID_HOST_OUT");
115       if (android_host_out != nullptr) {
116         setenv("ANDROID_ROOT", android_host_out, 1);
117       } else {
118         // Build it from ANDROID_BUILD_TOP or cwd
119         std::string root;
120         const char* android_build_top = getenv("ANDROID_BUILD_TOP");
121         if (android_build_top != nullptr) {
122           root += android_build_top;
123         } else {
124           // Not set by build server, so default to current directory
125           char* cwd = getcwd(nullptr, 0);
126           setenv("ANDROID_BUILD_TOP", cwd, 1);
127           root += cwd;
128           free(cwd);
129         }
130 #if defined(__linux__)
131         root += "/out/host/linux-x86";
132 #elif defined(__APPLE__)
133         root += "/out/host/darwin-x86";
134 #else
135 #error unsupported OS
136 #endif
137         setenv("ANDROID_ROOT", root.c_str(), 1);
138       }
139     }
140     setenv("LD_LIBRARY_PATH", ":", 0);  // Required by java.lang.System.<clinit>.
141 
142     // Not set by build server, so default
143     if (getenv("ANDROID_HOST_OUT") == nullptr) {
144       setenv("ANDROID_HOST_OUT", getenv("ANDROID_ROOT"), 1);
145     }
146   }
147 }
148 
SetUpAndroidData(std::string & android_data)149 void CommonRuntimeTest::SetUpAndroidData(std::string& android_data) {
150   // On target, Cannot use /mnt/sdcard because it is mounted noexec, so use subdir of dalvik-cache
151   if (IsHost()) {
152     const char* tmpdir = getenv("TMPDIR");
153     if (tmpdir != nullptr && tmpdir[0] != 0) {
154       android_data = tmpdir;
155     } else {
156       android_data = "/tmp";
157     }
158   } else {
159     android_data = "/data/dalvik-cache";
160   }
161   android_data += "/art-data-XXXXXX";
162   if (mkdtemp(&android_data[0]) == nullptr) {
163     PLOG(FATAL) << "mkdtemp(\"" << &android_data[0] << "\") failed";
164   }
165   setenv("ANDROID_DATA", android_data.c_str(), 1);
166 }
167 
TearDownAndroidData(const std::string & android_data,bool fail_on_error)168 void CommonRuntimeTest::TearDownAndroidData(const std::string& android_data, bool fail_on_error) {
169   if (fail_on_error) {
170     ASSERT_EQ(rmdir(android_data.c_str()), 0);
171   } else {
172     rmdir(android_data.c_str());
173   }
174 }
175 
176 
LoadExpectSingleDexFile(const char * location)177 const DexFile* CommonRuntimeTest::LoadExpectSingleDexFile(const char* location) {
178   std::vector<const DexFile*> dex_files;
179   std::string error_msg;
180   if (!DexFile::Open(location, location, &error_msg, &dex_files)) {
181     LOG(FATAL) << "Could not open .dex file '" << location << "': " << error_msg << "\n";
182     return nullptr;
183   } else {
184     CHECK_EQ(1U, dex_files.size()) << "Expected only one dex file in " << location;
185     return dex_files[0];
186   }
187 }
188 
SetUp()189 void CommonRuntimeTest::SetUp() {
190   SetUpAndroidRoot();
191   SetUpAndroidData(android_data_);
192   dalvik_cache_.append(android_data_.c_str());
193   dalvik_cache_.append("/dalvik-cache");
194   int mkdir_result = mkdir(dalvik_cache_.c_str(), 0700);
195   ASSERT_EQ(mkdir_result, 0);
196 
197   MemMap::Init();  // For LoadExpectSingleDexFile
198 
199   std::string error_msg;
200   java_lang_dex_file_ = LoadExpectSingleDexFile(GetLibCoreDexFileName().c_str());
201   boot_class_path_.push_back(java_lang_dex_file_);
202 
203   std::string min_heap_string(StringPrintf("-Xms%zdm", gc::Heap::kDefaultInitialSize / MB));
204   std::string max_heap_string(StringPrintf("-Xmx%zdm", gc::Heap::kDefaultMaximumSize / MB));
205 
206   callbacks_.reset(new NoopCompilerCallbacks());
207 
208   RuntimeOptions options;
209   options.push_back(std::make_pair("bootclasspath", &boot_class_path_));
210   options.push_back(std::make_pair("-Xcheck:jni", nullptr));
211   options.push_back(std::make_pair(min_heap_string.c_str(), nullptr));
212   options.push_back(std::make_pair(max_heap_string.c_str(), nullptr));
213   options.push_back(std::make_pair("compilercallbacks", callbacks_.get()));
214   SetUpRuntimeOptions(&options);
215   if (!Runtime::Create(options, false)) {
216     LOG(FATAL) << "Failed to create runtime";
217     return;
218   }
219   runtime_.reset(Runtime::Current());
220   class_linker_ = runtime_->GetClassLinker();
221   class_linker_->FixupDexCaches(runtime_->GetResolutionMethod());
222   class_linker_->RunRootClinits();
223 
224   // Runtime::Create acquired the mutator_lock_ that is normally given away when we
225   // Runtime::Start, give it away now and then switch to a more managable ScopedObjectAccess.
226   Thread::Current()->TransitionFromRunnableToSuspended(kNative);
227 
228   // We're back in native, take the opportunity to initialize well known classes.
229   WellKnownClasses::Init(Thread::Current()->GetJniEnv());
230 
231   // Create the heap thread pool so that the GC runs in parallel for tests. Normally, the thread
232   // pool is created by the runtime.
233   runtime_->GetHeap()->CreateThreadPool();
234   runtime_->GetHeap()->VerifyHeap();  // Check for heap corruption before the test
235 }
236 
ClearDirectory(const char * dirpath)237 void CommonRuntimeTest::ClearDirectory(const char* dirpath) {
238   ASSERT_TRUE(dirpath != nullptr);
239   DIR* dir = opendir(dirpath);
240   ASSERT_TRUE(dir != nullptr);
241   dirent* e;
242   struct stat s;
243   while ((e = readdir(dir)) != nullptr) {
244     if ((strcmp(e->d_name, ".") == 0) || (strcmp(e->d_name, "..") == 0)) {
245       continue;
246     }
247     std::string filename(dirpath);
248     filename.push_back('/');
249     filename.append(e->d_name);
250     int stat_result = lstat(filename.c_str(), &s);
251     ASSERT_EQ(0, stat_result) << "unable to stat " << filename;
252     if (S_ISDIR(s.st_mode)) {
253       ClearDirectory(filename.c_str());
254       int rmdir_result = rmdir(filename.c_str());
255       ASSERT_EQ(0, rmdir_result) << filename;
256     } else {
257       int unlink_result = unlink(filename.c_str());
258       ASSERT_EQ(0, unlink_result) << filename;
259     }
260   }
261   closedir(dir);
262 }
263 
TearDown()264 void CommonRuntimeTest::TearDown() {
265   const char* android_data = getenv("ANDROID_DATA");
266   ASSERT_TRUE(android_data != nullptr);
267   ClearDirectory(dalvik_cache_.c_str());
268   int rmdir_cache_result = rmdir(dalvik_cache_.c_str());
269   ASSERT_EQ(0, rmdir_cache_result);
270   TearDownAndroidData(android_data_, true);
271 
272   // icu4c has a fixed 10-element array "gCommonICUDataArray".
273   // If we run > 10 tests, we fill that array and u_setCommonData fails.
274   // There's a function to clear the array, but it's not public...
275   typedef void (*IcuCleanupFn)();
276   void* sym = dlsym(RTLD_DEFAULT, "u_cleanup_" U_ICU_VERSION_SHORT);
277   CHECK(sym != nullptr) << dlerror();
278   IcuCleanupFn icu_cleanup_fn = reinterpret_cast<IcuCleanupFn>(sym);
279   (*icu_cleanup_fn)();
280 
281   STLDeleteElements(&opened_dex_files_);
282 
283   Runtime::Current()->GetHeap()->VerifyHeap();  // Check for heap corruption after the test
284 }
285 
GetLibCoreDexFileName()286 std::string CommonRuntimeTest::GetLibCoreDexFileName() {
287   return GetDexFileName("core-libart");
288 }
289 
GetDexFileName(const std::string & jar_prefix)290 std::string CommonRuntimeTest::GetDexFileName(const std::string& jar_prefix) {
291   if (IsHost()) {
292     const char* host_dir = getenv("ANDROID_HOST_OUT");
293     CHECK(host_dir != nullptr);
294     return StringPrintf("%s/framework/%s-hostdex.jar", host_dir, jar_prefix.c_str());
295   }
296   return StringPrintf("%s/framework/%s.jar", GetAndroidRoot(), jar_prefix.c_str());
297 }
298 
GetTestAndroidRoot()299 std::string CommonRuntimeTest::GetTestAndroidRoot() {
300   if (IsHost()) {
301     const char* host_dir = getenv("ANDROID_HOST_OUT");
302     CHECK(host_dir != nullptr);
303     return host_dir;
304   }
305   return GetAndroidRoot();
306 }
307 
308 // Check that for target builds we have ART_TARGET_NATIVETEST_DIR set.
309 #ifdef ART_TARGET
310 #ifndef ART_TARGET_NATIVETEST_DIR
311 #error "ART_TARGET_NATIVETEST_DIR not set."
312 #endif
313 // Wrap it as a string literal.
314 #define ART_TARGET_NATIVETEST_DIR_STRING STRINGIFY(ART_TARGET_NATIVETEST_DIR) "/"
315 #else
316 #define ART_TARGET_NATIVETEST_DIR_STRING ""
317 #endif
318 
OpenTestDexFiles(const char * name)319 std::vector<const DexFile*> CommonRuntimeTest::OpenTestDexFiles(const char* name) {
320   CHECK(name != nullptr);
321   std::string filename;
322   if (IsHost()) {
323     filename += getenv("ANDROID_HOST_OUT");
324     filename += "/framework/";
325   } else {
326     filename += ART_TARGET_NATIVETEST_DIR_STRING;
327   }
328   filename += "art-gtest-";
329   filename += name;
330   filename += ".jar";
331   std::string error_msg;
332   std::vector<const DexFile*> dex_files;
333   bool success = DexFile::Open(filename.c_str(), filename.c_str(), &error_msg, &dex_files);
334   CHECK(success) << "Failed to open '" << filename << "': " << error_msg;
335   for (const DexFile* dex_file : dex_files) {
336     CHECK_EQ(PROT_READ, dex_file->GetPermissions());
337     CHECK(dex_file->IsReadOnly());
338   }
339   opened_dex_files_.insert(opened_dex_files_.end(), dex_files.begin(), dex_files.end());
340   return dex_files;
341 }
342 
OpenTestDexFile(const char * name)343 const DexFile* CommonRuntimeTest::OpenTestDexFile(const char* name) {
344   std::vector<const DexFile*> vector = OpenTestDexFiles(name);
345   EXPECT_EQ(1U, vector.size());
346   return vector[0];
347 }
348 
LoadDex(const char * dex_name)349 jobject CommonRuntimeTest::LoadDex(const char* dex_name) {
350   std::vector<const DexFile*> dex_files = OpenTestDexFiles(dex_name);
351   CHECK_NE(0U, dex_files.size());
352   for (const DexFile* dex_file : dex_files) {
353     class_linker_->RegisterDexFile(*dex_file);
354   }
355   ScopedObjectAccessUnchecked soa(Thread::Current());
356   ScopedLocalRef<jobject> class_loader_local(soa.Env(),
357       soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader));
358   jobject class_loader = soa.Env()->NewGlobalRef(class_loader_local.get());
359   soa.Self()->SetClassLoaderOverride(soa.Decode<mirror::ClassLoader*>(class_loader_local.get()));
360   Runtime::Current()->SetCompileTimeClassPath(class_loader, dex_files);
361   return class_loader;
362 }
363 
CheckJniAbortCatcher()364 CheckJniAbortCatcher::CheckJniAbortCatcher() : vm_(Runtime::Current()->GetJavaVM()) {
365   vm_->check_jni_abort_hook = Hook;
366   vm_->check_jni_abort_hook_data = &actual_;
367 }
368 
~CheckJniAbortCatcher()369 CheckJniAbortCatcher::~CheckJniAbortCatcher() {
370   vm_->check_jni_abort_hook = nullptr;
371   vm_->check_jni_abort_hook_data = nullptr;
372   EXPECT_TRUE(actual_.empty()) << actual_;
373 }
374 
Check(const char * expected_text)375 void CheckJniAbortCatcher::Check(const char* expected_text) {
376   EXPECT_TRUE(actual_.find(expected_text) != std::string::npos) << "\n"
377       << "Expected to find: " << expected_text << "\n"
378       << "In the output   : " << actual_;
379   actual_.clear();
380 }
381 
Hook(void * data,const std::string & reason)382 void CheckJniAbortCatcher::Hook(void* data, const std::string& reason) {
383   // We use += because when we're hooking the aborts like this, multiple problems can be found.
384   *reinterpret_cast<std::string*>(data) += reason;
385 }
386 
387 }  // namespace art
388 
389 namespace std {
390 
391 template <typename T>
operator <<(std::ostream & os,const std::vector<T> & rhs)392 std::ostream& operator<<(std::ostream& os, const std::vector<T>& rhs) {
393 os << ::art::ToString(rhs);
394 return os;
395 }
396 
397 }  // namespace std
398