Add missing SIRT to LoadNativeLibrary.

When we transition to kWaitingForJniOnLoad, we are suspended and
a GC can occur. This caused issues since classloaders are movable.

Change-Id: Iae59019c22ac64322a82300107d06a4323ee602b

4 files changed, 16 insertions, 11 deletions

diff --git a/runtime/jni_internal.cc b/runtime/jni_internal.cc
index 30b4ee8..5cd09c2 100644
--- a/runtime/jni_internal.cc
+++ b/runtime/jni_internal.cc
@@ -3217,7 +3217,8 @@ void JavaVMExt::DumpReferenceTables(std::ostream& os) {
   }
 }
 
-bool JavaVMExt::LoadNativeLibrary(const std::string& path, ClassLoader* class_loader,
+bool JavaVMExt::LoadNativeLibrary(const std::string& path,
+                                  const SirtRef<ClassLoader>& class_loader,
                                   std::string* detail) {
   detail->clear();
 
@@ -3233,18 +3234,18 @@ bool JavaVMExt::LoadNativeLibrary(const std::string& path, ClassLoader* class_lo
     library = libraries->Get(path);
   }
   if (library != NULL) {
-    if (library->GetClassLoader() != class_loader) {
+    if (library->GetClassLoader() != class_loader.get()) {
       // The library will be associated with class_loader. The JNI
       // spec says we can't load the same library into more than one
       // class loader.
       StringAppendF(detail, "Shared library \"%s\" already opened by "
           "ClassLoader %p; can't open in ClassLoader %p",
-          path.c_str(), library->GetClassLoader(), class_loader);
+          path.c_str(), library->GetClassLoader(), class_loader.get());
       LOG(WARNING) << detail;
       return false;
     }
     VLOG(jni) << "[Shared library \"" << path << "\" already loaded in "
-              << "ClassLoader " << class_loader << "]";
+              << "ClassLoader " << class_loader.get() << "]";
     if (!library->CheckOnLoadResult()) {
       StringAppendF(detail, "JNI_OnLoad failed on a previous attempt "
           "to load \"%s\"", path.c_str());
@@ -3285,18 +3286,19 @@ bool JavaVMExt::LoadNativeLibrary(const std::string& path, ClassLoader* class_lo
     MutexLock mu(self, libraries_lock);
     library = libraries->Get(path);
     if (library == NULL) {  // We won race to get libraries_lock
-      library = new SharedLibrary(path, handle, class_loader);
+      library = new SharedLibrary(path, handle, class_loader.get());
       libraries->Put(path, library);
       created_library = true;
     }
   }
   if (!created_library) {
     LOG(INFO) << "WOW: we lost a race to add shared library: "
-        << "\"" << path << "\" ClassLoader=" << class_loader;
+        << "\"" << path << "\" ClassLoader=" << class_loader.get();
     return library->CheckOnLoadResult();
   }
 
-  VLOG(jni) << "[Added shared library \"" << path << "\" for ClassLoader " << class_loader << "]";
+  VLOG(jni) << "[Added shared library \"" << path << "\" for ClassLoader " << class_loader.get()
+      << "]";
 
   bool was_successful = false;
   void* sym = dlsym(handle, "JNI_OnLoad");
@@ -3311,7 +3313,7 @@ bool JavaVMExt::LoadNativeLibrary(const std::string& path, ClassLoader* class_lo
     typedef int (*JNI_OnLoadFn)(JavaVM*, void*);
     JNI_OnLoadFn jni_on_load = reinterpret_cast<JNI_OnLoadFn>(sym);
     SirtRef<ClassLoader> old_class_loader(self, self->GetClassLoaderOverride());
-    self->SetClassLoaderOverride(class_loader);
+    self->SetClassLoaderOverride(class_loader.get());
 
     int version = 0;
     {
diff --git a/runtime/jni_internal.h b/runtime/jni_internal.h
index 96f7ae0..cd3c5cb 100644
--- a/runtime/jni_internal.h
+++ b/runtime/jni_internal.h
@@ -25,6 +25,7 @@
 #include "reference_table.h"
 #include "root_visitor.h"
 #include "runtime.h"
+#include "sirt_ref.h"
 
 #include <iosfwd>
 #include <string>
@@ -72,7 +73,7 @@ class JavaVMExt : public JavaVM {
    * Returns 'true' on success. On failure, sets 'detail' to a
    * human-readable description of the error.
    */
-  bool LoadNativeLibrary(const std::string& path, mirror::ClassLoader* class_loader,
+  bool LoadNativeLibrary(const std::string& path, const SirtRef<mirror::ClassLoader>& class_loader,
                          std::string* detail)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
diff --git a/runtime/native/java_lang_Runtime.cc b/runtime/native/java_lang_Runtime.cc
index e969fcf..0629f4d 100644
--- a/runtime/native/java_lang_Runtime.cc
+++ b/runtime/native/java_lang_Runtime.cc
@@ -64,7 +64,8 @@ static jstring Runtime_nativeLoad(JNIEnv* env, jclass, jstring javaFilename, job
   std::string detail;
   {
     ScopedObjectAccess soa(env);
-    mirror::ClassLoader* classLoader = soa.Decode<mirror::ClassLoader*>(javaLoader);
+    SirtRef<mirror::ClassLoader> classLoader(soa.Self(),
+                                             soa.Decode<mirror::ClassLoader*>(javaLoader));
     JavaVMExt* vm = Runtime::Current()->GetJavaVM();
     bool success = vm->LoadNativeLibrary(filename.c_str(), classLoader, &detail);
     if (success) {
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index d070207..bcd3d31 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -1087,7 +1087,8 @@ void Runtime::InitNativeMethods() {
     std::string mapped_name(StringPrintf(OS_SHARED_LIB_FORMAT_STR, "javacore"));
     std::string reason;
     self->TransitionFromSuspendedToRunnable();
-    if (!instance_->java_vm_->LoadNativeLibrary(mapped_name, NULL, &reason)) {
+    SirtRef<mirror::ClassLoader> class_loader(self, nullptr);
+    if (!instance_->java_vm_->LoadNativeLibrary(mapped_name, class_loader, &reason)) {
       LOG(FATAL) << "LoadNativeLibrary failed for \"" << mapped_name << "\": " << reason;
     }
     self->TransitionFromRunnableToSuspended(kNative);